Malgré le fait que nous parlerons de l'un des sujets fondamentaux, cet article est rédigé pour des professionnels expérimentés. Le but est de montrer quelles idées fausses les débutants ont en matière de programmation. Pour les développeurs en exercice, ces problèmes sont depuis longtemps résolus, oubliés ou pas du tout remarqués. L'article peut s'avérer utile si vous avez soudainement besoin d'aider quelqu'un sur ce sujet. L'article établit des parallèles avec des éléments de divers livres sur la programmation de Schildt, Stroustrup et Okulov.
Le thème des cycles a été choisi car de nombreuses personnes en sont exclues lors de la maîtrise de la programmation.
Cette technique est conçue pour les élèves faibles. En règle générale, les personnes fortes ne restent pas coincées sur ce sujet et il n'est pas nécessaire de leur proposer des techniques spéciales. L’objectif secondaire de l’article est de faire passer cette technique du cours « des travaux pour tous les élèves, mais un seul enseignant » au cours « des travaux pour tous les élèves, tous les enseignants ». Je ne revendique pas une originalité absolue. Si vous utilisez déjà une méthodologie similaire pour enseigner ce sujet, veuillez indiquer en quoi votre version diffère. Si vous décidez de l'utiliser, dites-nous comment cela s'est passé. Si une technique similaire est décrite dans un livre, veuillez écrire son nom.
J'ai travaillé cette technique pendant 4 ans, en étudiant individuellement avec des étudiants de différents niveaux de formation. Au total, il y a une cinquantaine d'étudiants et deux mille heures de cours. Au début, les étudiants restaient toujours bloqués sur ce sujet et partaient. Après chaque étudiant, la méthodologie et le matériel ont été ajustés. Au cours de la dernière année, les étudiants n'ont plus été bloqués sur ce sujet, j'ai donc décidé de partager mes découvertes.
Pourquoi tant de lettres ? Les cycles sont tellement élémentaires !
Comme je l'ai écrit ci-dessus, pour les développeurs en exercice et pour les étudiants forts, la complexité du concept de boucles peut être sous-estimée. Par exemple, vous pouvez donner une longue conférence, voir des têtes hocher la tête et des yeux intelligents. Mais lorsque vous essayez de résoudre un problème, la stupeur et des problèmes inexplicables commencent. Après le cours, les étudiants n’avaient probablement qu’une compréhension partielle. La situation est aggravée par le fait que les étudiants eux-mêmes ne peuvent pas exprimer exactement quelle est leur illusion.
Un jour, j'ai réalisé que les élèves percevaient mes exemples comme des hiéroglyphes. Autrement dit, comme des morceaux de texte indivisibles dans lesquels vous devez ajouter une lettre « magique » et cela fonctionnera.
Parfois, j'ai remarqué que les étudiants pensent que pour résoudre un problème spécifique, il faut autre chose un design que je n’ai pas encore couvert. Bien que la solution ne nécessite qu'une légère modification de l'exemple.
J'ai donc eu l'idée qu'il ne fallait pas se concentrer sur la syntaxe des expressions, mais sur l'idée de refactoriser du code répétitif à l'aide de boucles. Une fois que les étudiants maîtrisent cette idée, toute syntaxe peut être améliorée avec peu de pratique.
À qui et pourquoi j’enseigne ?
Puisqu’il n’y a pas d’examen d’entrée, les classes peuvent inclure des étudiants aussi bien forts que très faibles. Vous pouvez en savoir plus sur mes étudiants dans l'article
Je me suis efforcé de faire en sorte que tous ceux qui souhaitent apprendre la programmation puissent l'apprendre.
Mes cours ont lieu individuellement et l'étudiant paie son propre argent pour chacun. Il semblerait que les étudiants optimisent les coûts et exigent le minimum. Cependant, les gens vont aux cours en présentiel avec un professeur en direct non pas pour les connaissances elles-mêmes, mais pour la confiance dans ce qu'ils ont appris, pour un sentiment de progrès et pour l'approbation de l'expert (enseignant). Si les élèves ne sentent pas de progrès dans leur apprentissage, ils partiront. En général, les cours peuvent être structurés de manière à ce que les élèves ressentent des progrès en augmentant le nombre de structures familières. C'est-à-dire que d'abord nous étudions en détail, puis nous étudions pendant, puis faisons pendant, et maintenant nous avons un cours mille et une nuits prêt, dans lequel les cycles seuls sont étudiés pendant deux mois, et à la fin - un étudiant qui a écrit une bibliothèque standard sous dictée. Cependant, pour résoudre des problèmes pratiques, vous avez besoin non seulement d'une connaissance du matériau, mais également d'une indépendance dans son application et dans la recherche de nouvelles informations. Par conséquent, pour les cours en présentiel, je pense que le principe correct est d’enseigner le minimum et d’encourager l’étude indépendante des nuances et des sujets connexes. Dans le domaine des boucles, je considère la construction while comme le minimum. Vous pouvez en comprendre le principe. Connaissant le principe, vous pouvez maîtriser à la fois pour vous-même et pendant que vous le faites.
Pour que les élèves faibles maîtrisent la matière, il ne suffit pas de décrire la syntaxe. Il est nécessaire de donner des tâches plus simples mais variées et de décrire des exemples plus en détail. En fin de compte, la vitesse de développement est limitée par la capacité de l’élève à transformer des expressions et à rechercher des modèles. Pour les étudiants intelligents, la plupart des devoirs seront ennuyeux. Lorsque vous étudiez avec eux, vous n’êtes pas obligé d’insister pour résoudre 100 % des problèmes. Mon matériel peut être consulté sur . Certes, le référentiel ressemble plus au grimoire d'un sorcier - personne d'autre que moi ne comprendra ce qui se trouve où, et si vous échouez au contrôle, vous pouvez devenir fou
La méthodologie est orientée vers la pratique
La théorie est expliquée à l'aide de l'exemple de la résolution d'un problème. Dans un cours de base de programmation où sont enseignés les branches et les boucles, il n'est tout simplement pas possible de donner un cours utile sur un sujet pendant une heure entière. 15 à 20 minutes suffisent pour expliquer le concept. Les principales difficultés surviennent lors de l'exécution de tâches pratiques.
Les enseignants débutants peuvent présenter des opérateurs, des branches, des boucles et des tableaux en un seul cours. Mais leurs étudiants seront confrontés au problème de l'assimilation de ces informations.
Après tout, vous devez non seulement raconter le matériel, mais également vous assurer que les auditeurs le comprennent.
Le fait de maîtriser un sujet est déterminé par la manière dont l'étudiant fait face au travail indépendant.
Si un élève parvient à résoudre un problème sur un sujet sans l'aide d'un enseignant, alors le sujet est maîtrisé. Pour garantir l'autotest, chaque tâche est décrite dans un tableau avec des scénarios de test. Les tâches ont un ordre clair. Il n'est pas recommandé de sauter des tâches. Si la tâche en cours est trop difficile, passer à la suivante est inutile. C'est encore plus compliqué. Afin que l'élève puisse maîtriser la tâche complexe en cours, plusieurs techniques lui sont expliquées à partir de l'exemple du premier problème. En fait, tout le contenu du sujet se résume à des techniques permettant de surmonter les difficultés. Les cycles sont plutôt un effet secondaire.
La première tâche est toujours un exemple. La seconde diffère légèrement et s’effectue « en autonomie » immédiatement après la première sous la supervision d’un enseignant. Toutes les tâches ultérieures visent à prêter attention à diverses petites choses qui peuvent provoquer des idées fausses.
L'explication de l'exemple est un dialogue dans lequel l'étudiant doit faire appel à la propagation et à la validation croisée pour s'assurer qu'il maîtrise une partie de la matière.
Je serai banal et dirai que le premier exemple sur le sujet est très important. Si vous disposez du matériel nécessaire à un travail indépendant approfondi, les omissions du premier exemple peuvent être corrigées. S'il n'y a rien d'autre que l'exemple, alors l'étudiant ne maîtrisera probablement pas le sujet.
Pendant ou pour ?
L'une des questions controversées est le choix de la construction pour l'exemple : while ou for. Un jour, un de mes amis développeurs sans expérience en enseignement a passé une heure à me convaincre que la boucle for était la plus simple à comprendre. Les arguments se résumaient à « tout y est clair et disposé à sa place ». Cependant, la cause profonde des difficultés des vrais débutants est l'idée du cycle lui-même, et non son écriture. Si une personne ne comprend pas cette idée, elle aura alors des difficultés avec la syntaxe. Dès que l’idée se concrétise, les problèmes de conception de code disparaissent d’eux-mêmes.
Dans mes matériaux, le thème des boucles suit le thème des embranchements. La similitude externe de if et while nous permet de faire une analogie directe : « lorsque la condition dans l’en-tête est vraie, alors le corps est exécuté ». La seule particularité du cycle est que le corps est exécuté plusieurs fois.
Mon deuxième argument est que while nécessite moins de formatage que for. Moins de formatage signifie moins d’erreurs stupides avec des virgules et des parenthèses manquantes. Les débutants n’ont pas encore développé suffisamment d’attention et de minutie pour éviter automatiquement les erreurs de syntaxe.
Le troisième argument est expliqué dans de nombreux bons livres comme le premier argument.
Si l'élève peut facilement transformer des expressions, alors vous pouvez en parler en passant. L'étudiant choisira ensuite ce qu'il préfère. Si les transformations causent des difficultés, il vaut mieux ne pas détourner votre attention. Laissez l’élève d’abord tout résoudre en utilisant while. Une fois que vous maîtrisez le sujet des boucles, vous pouvez réécrire les solutions pour vous entraîner à convertir while en for.
Les boucles de postcondition sont une bête assez rare. Je n'y consacre pas du tout de temps. Si un étudiant maîtrise les idées d’identification de modèles et de transformation d’expressions, il peut les comprendre sans mon aide.
Lors de la démonstration du premier exemple à des étudiants forts, j'attire l'attention sur le fait que dans le premier exemple, il est important d'enregistrer non seulement la solution, mais également toute la chaîne d'actions qui ont conduit au résultat. Les étudiants paresseux peuvent négliger l’écriture et copier uniquement l’algorithme final. Ils doivent être convaincus qu’un jour une tâche difficile se présentera à eux. Pour le résoudre, vous devrez suivre les étapes comme dans cet exemple. C'est pourquoi il est important d'enregistrer toutes les étapes. Dans les problèmes suivants, il sera possible de laisser uniquement la version finale de la solution.
L'idée principale de l'automatisation est que nous confions à un ordinateur le travail de routine d'une personne. L'une des techniques de base consiste à écrire des boucles. Il est utilisé lorsque plusieurs actions répétitives identiques sont écrites consécutivement dans un programme.
Mieux vaut explicite qu’implicite
Cela peut sembler une bonne idée d’afficher la même phrase plusieurs fois lors de la première tâche de boucle. Par exemple:
Hourra, ça marche !
Hourra, ça marche !
Hourra, ça marche !
Hourra, ça marche !
Hourra, ça marche !
Hourra, ça marche !
Hourra, ça marche !
Hourra, ça marche !
Cette option est mauvaise car la valeur du compteur n'est pas visible dans la sortie. C'est un problème pour les débutants. Ne la sous-estimez pas. Au début, cette tâche était la première, et la tâche consistant à dériver une série de nombres par ordre croissant était la seconde. Il a fallu introduire les termes supplémentaires « cycle N fois » et « cycle de A à B », qui sont essentiellement la même chose. Afin de ne pas créer d'entités inutiles, j'ai décidé de montrer uniquement un exemple avec la sortie d'une série de nombres. Peu de gens parviennent à apprendre à tenir un compteur dans leur tête et à modéliser le comportement d'un programme dans leur tête sans préparation. Certains étudiants rencontrent pour la première fois une modélisation mentale sur le thème des cycles.
Après un peu de pratique, je donne la tâche de répéter le même texte à résoudre de manière indépendante. Si vous donnez d’abord un jeton visible, puis un autre invisible, les élèves auront moins de problèmes. Parfois, le conseil « n’écrivez pas le compteur sur l’écran » suffit.
Comment les autres l’expliquent-ils ?
Dans la plupart des supports pédagogiques disponibles sur Internet, la syntaxe du cycle est donnée dans le cadre d'un « cours magistral ». Par exemple, sur Developer.mozilla.org (actuellement), plusieurs autres constructions sont décrites avec la boucle while. Dans ce cas, seuls les designs eux-mêmes sont donnés sous forme de modèles. Le résultat de leur lancement est décrit avec des mots, mais il n'y a aucune illustration. À mon avis, une telle présentation du sujet multiplie par zéro l'utilité de tels matériaux. L'étudiant peut réécrire le code et l'exécuter lui-même, mais il a toujours besoin d'un standard de comparaison. Comment comprendre qu’un exemple a été réécrit correctement s’il n’y a rien avec quoi comparer le résultat ?
Lorsqu’on donne seulement un modèle, sans exemple, cela devient encore plus difficile pour l’étudiant. Comment comprendre que les fragments de code sont correctement placés dans le modèle ? Tu peux essayer d'écrire en quelque sorte, puis exécutez. Mais s'il n'y a pas de norme pour comparer le résultat, le lancement n'aidera pas non plus.
Dans le cours C++ sur Intuitive, la syntaxe des boucles est enfouie dans la troisième page du cours 4 sur le thème « opérateurs ». Lors de l’explication de la syntaxe des boucles, un accent particulier est mis sur le terme « opérateur ». Le terme est présenté comme un ensemble de faits comme « symbole ; ceci est une instruction", "{} est une instruction composée", "le corps de la boucle doit être une instruction". Je n’aime pas cette approche car elle semble cacher des relations importantes derrière un seul terme. L'analyse du code source d'un programme en termes à ce niveau est nécessaire aux développeurs de compilateurs pour implémenter la spécification du langage, mais pas aux étudiants en première approximation. Les nouveaux venus dans le domaine de la programmation sont rarement assez méticuleux pour prêter autant d’attention aux termes. C’est une personne rare qui se souvient et comprend de nouveaux mots du premier coup. Presque personne ne peut appliquer correctement un terme qu’il vient d’apprendre. Par conséquent, les étudiants reçoivent de nombreuses erreurs telles que « J'ai écrit while(a<7);{, mais le programme ne fonctionne pas. »
À mon avis, au début il vaut mieux donner la syntaxe de la construction immédiatement avec des parenthèses. L’option sans parenthèses ne doit être expliquée que si l’élève a une question précise : « pourquoi il n’y a pas de parenthèses et ça marche ».
Dans le livre d'Okulov de 2012 « Fundamentals of Programming », une introduction aux boucles commence par le modèle for, donne ensuite des recommandations pour son utilisation, puis passe immédiatement à la section expérimentale de la leçon. Je comprends que le livre a été écrit pour cette minorité d’étudiants très compétents qui viennent rarement à mes cours.
Dans les livres populaires, le résultat des fragments de code est toujours écrit. Par exemple, l’édition 8 de « Java 2015. The Complete Guide » de Shildt. Tout d'abord, un modèle est donné, puis un exemple de programme et immédiatement après - le résultat de l'exécution.
À titre d'exemple, considérons une boucle while qui fait l'inverse
compte à rebours commençant à 10, et exactement 10 lignes de « mesures » sont affichées ://Продемонстрировать применение оператора цикла while class While { public static void main(String args []) { int n = 10; while (n > 0) { System.out.println("такт " + n); n--; } } }Une fois exécuté, ce programme génère dix « cycles » comme suit :
такт 10
такт 9
такт 8
такт 7
такт 6
такт 5
такт 4
такт 3
такт 2
такт 1
L'approche consistant à décrire un modèle, un exemple de programme et le résultat du programme est également utilisée dans le livre « Javascript for Kids » et dans le cours js sur w3schools.com. Le format de la page Web permet même à cet exemple d'être interactif.
Le livre de Stroustrup de 2016, Principles and Practice Using C++, est allé encore plus loin. La première étape consiste à expliquer quel résultat doit être obtenu, puis le texte du programme est affiché. De plus, ils ne prennent pas seulement comme exemple un programme aléatoire, mais proposent une excursion dans l'histoire. Cela permet d’attirer l’attention sur ce point : « Écoutez, ce n’est pas juste un texte inutile. Vous voyez quelque chose de significatif.
À titre d'exemple d'itération, considérons le premier programme exécuté sur une machine à programme stocké (EDSAC). Il a été écrit par David Wheeler au laboratoire informatique de l'université de Cambridge, en Angleterre, le 6 mai 1949. Ce programme calcule et imprime une simple liste de carrés.
0 0
1 1
2 4
3 9
4 16
...
98 9604
99 9801
Ici, chaque ligne contient un nombre suivi d'un caractère de tabulation (« t ») et du carré de ce nombre. La version C++ de ce programme ressemble à ceci ://Вычисляем и распечатываем таблицу квадратов чисел 0-99 int main() { int i = 0; // Начинаем с нуля while(i < 100){ cout << i << 't' << square(i) << 'n'; ++i; } }
Il est intéressant de noter que le modèle de syntaxe n'est pas décrit dans ce livre. Stroustrup dans le manuel de l'instructeur () souligne qu'il respecte l'intelligence de ses étudiants. Peut-être que la capacité d’identifier un modèle dans plusieurs exemples est considérée comme une manifestation d’une telle intelligence.
Comme je m'explique
L'approche de Stroustrup : décrire le résultat, puis résoudre le problème, puis procéder à une analyse indépendante par l'étudiant - semble la plus réfléchie. Par conséquent, j'ai décidé de le prendre comme base, mais de le raconter en utilisant un exemple moins historique - la tâche de dériver une « table des matières ». Il constitue un point d'ancrage reconnaissable pour que vous puissiez ensuite dire « souvenez-vous de la tâche concernant la table des matières » et pour que les élèves se souviennent exactement de cela. Dans mon exemple, j’ai essayé d’éviter deux autres idées fausses les plus courantes. Ensuite, j'écrirai à leur sujet plus en détail.
Dans cette tâche, nous découvrons des techniques permettant de résoudre des problèmes complexes. La décision initiale doit être prise de manière primitive et simple. Eh bien, vous pourrez alors réfléchir à la manière d’améliorer cette solution.
Введение
Глава 1
Глава 2
Глава 3
Глава 4
Глава 5
Глава 6
Глава 7
Заключение
D'après mes observations, l'approche « modèle-exemple-résultat » dans diverses combinaisons conduit toujours au fait que les élèves perçoivent le cycle comme un hiéroglyphe. Cela s'est manifesté par le fait qu'ils ne comprenaient pas pourquoi il y avait une condition pour écrire ici, comment choisir entre i++ et i — et d'autres choses apparemment évidentes. Pour éviter ces idées fausses, l’approche consistant à parler de cycles devrait mettre l’accent sur le sens de répéter des actions identiques et de les formaliser ensuite seulement à l’aide d’une structure. Par conséquent, avant de donner la syntaxe de la boucle, vous devez résoudre le problème de front. Une solution primitive au problème de la table des matières ressemble à ceci :
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("Заключение");
Comment peut-il être amélioré ?
Remplacez les actions monotones par un cycle.
Quelles actions sont répétées d'affilée sans changement ?
Il n'y en a pas dans ce fragment. Cependant, les commandes permettant d'afficher le mot « Chapitre » avec un numéro sont très similaires les unes aux autres.
Par conséquent, l’étape suivante consiste à trouver la différence entre les fragments. Ce n'est que dans cette tâche que tout est évident, alors ce ne sont pas des commandes uniques qui seront répétées, mais des blocs de code de 5 lignes ou plus. Vous devrez chercher non seulement dans la liste des commandes, mais aussi dans les constructions de branchements ou de boucles.
Dans l'exemple, la différence entre les commandes réside dans le numéro après le mot « Chapitre ».
Une fois la différence trouvée, vous devez comprendre le modèle de changement. Le fragment différent est le numéro ? Est-ce qu’il augmente ou diminue constamment ? Comment évolue la valeur d’un numéro entre deux équipes côte à côte ?
Dans l'exemple, le nombre après le mot « Chapitre » augmente par incréments de 1. La différence est trouvée, le motif est révélé. Vous pouvez maintenant remplacer le fragment différent par une variable.
Vous devez déclarer une telle variable avant le premier des fragments répétitifs. Une telle variable est généralement appelée I ou j ou quelque chose de plus détaillé. Sa valeur initiale doit être égale à la première valeur affichée à l'écran. Dans l'exemple, la première valeur est 1.
Quelle valeur initiale prendre pour afficher la série de nombres « 100, 101, 102, 103, 104, 105 » ?
Le premier nombre de cette série est 100.
Après chaque commande de sortie, vous devez augmenter la valeur de cette variable de 1. Cette unité est l'étape de changement.
Quelle étape sera la série de nombres « 100, 102, 104, 106 » ?
Étape 2 dans cette rangée.
Après avoir remplacé le fragment différent par une variable, le code ressemblera à ceci :
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("Заключение");
Après avoir appliqué la technique « exprimer le modèle d'une variable » dans le code, vous obtenez plusieurs groupes d'actions identiques qui s'enchaînent. Désormais, les actions répétitives peuvent être remplacées par un cycle.
La séquence de résolution d'un problème où vous devez utiliser des boucles comprend les étapes suivantes :
- Résolvez « de front » avec de nombreuses commandes distinctes
- Trouver un modèle
- Exprimer le modèle d'une variable
- Le design comme un cycle
Ensuite, de nouveaux termes sont introduits pour que l'élève ne se retrouve pas dans la situation du « Je comprends tout, mais je ne peux pas le dire » :
— un compteur est toujours une variable nécessaire pour suivre le nombre d'étapes dans une boucle. Il s'agit généralement d'un nombre entier comparé à la contrainte.
— contre-étape — description du modèle de contre-changements.
- contrainte - un nombre ou une variable avec lequel le compteur est comparé pour que l'algorithme soit final. La valeur du compteur change pour se rapprocher de la limite.
— corps de boucle — un ensemble de commandes qui seront répétées. Quand ils disent « la commande est écrite dans une boucle », ils parlent du corps.
— itération de boucle — exécution unique du corps de la boucle.
— condition de boucle — une expression logique qui détermine si une autre itération sera exécutée. (Il peut y avoir une confusion avec les structures de branchement ici)
Vous devez être préparé au fait qu'au début, les étudiants utiliseront des termes à d'autres fins. Cela s’applique aussi bien aux forts qu’aux faibles. Établir un langage commun est un art. Maintenant, je vais écrire brièvement : vous devez définir la tâche « mettre en surbrillance le fragment de code avec <term> » et utiliser vous-même correctement ces termes dans la conversation.
Après transformation par une boucle, le fragment est obtenu :
Console.WriteLine("Введение");
int i = 0;
while (i < 7) {
Console.WriteLine("Глава " + i);
i = i + 1;
}
Console.WriteLine("Заключение");La principale idée fausse
Une idée fausse très répandue parmi les étudiants est qu’ils placent des actions dans une boucle qui ne doivent être effectuées qu’une seule fois. Par exemple comme ceci :
;
int i = 0;
while (i < 7) {
Console.WriteLine("Введение")
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Заключение");
}
Les étudiants sont constamment confrontés à ce problème, au début et dans le cadre de problèmes plus complexes.
Conseil clé dans ce cas :
Combien de fois devez-vous répéter la commande : une ou plusieurs fois ?
Les commandes pour imprimer les mots "Introduction" et "Conclusion" et déclarer et initialiser la variable i ne sont pas comme les autres actions répétitives. Ils ne sont exécutés qu’une seule fois, ce qui signifie qu’ils doivent être écrits en dehors du corps de la boucle.
Les trois étapes de la solution doivent rester dans le code afin que vous puissiez vous y référer ultérieurement en cas de difficultés. Il suffit de commenter les deux premières options pour qu'elles ne gênent pas.
L'attention de l'étudiant doit être attirée sur les faits suivants :
— Dans une condition de boucle, un compteur et une limite sont généralement comparés. Le compteur peut changer dans le corps de la boucle, mais pas la limite. Pour enfreindre cette règle, vous devez formuler des raisons impérieuses.
— Les commandes d'affichage des mots « Introduction » et « Conclusion » sont situées à l'extérieur du corps de la boucle. Nous devons les exécuter 1 fois. "Introduction" - avant de répéter les actions, "Conclusion" - après.
Dans le processus de consolidation de ce sujet, de maîtrise des suivants, ainsi que de gestion des difficultés, il est utile, même pour les étudiants forts, de se poser la question : « Combien de fois cette action doit-elle être effectuée ? Un ou plusieurs ?
Développement de compétences complémentaires
Au cours des cycles d'études, les étudiants développent également la capacité de diagnostiquer et de résoudre des problèmes. Pour réaliser un diagnostic, l'étudiant doit présenter le résultat souhaité et le comparer avec le résultat réel. Les actions correctives dépendent de la différence entre elles.
Étant donné que les étudiants à ce stade ont encore peu d'idées sur le résultat « souhaité », ils peuvent se concentrer sur les données des tests. En règle générale, personne à ce stade ne comprend encore ce qui peut mal se passer et comment y remédier. Par conséquent, j'écris dans un cahier une description des problèmes typiques et plusieurs façons de les résoudre. Choisir celui qui convient le mieux est la tâche de l'étudiant lui-même.
Un enregistrement est nécessaire pour demander « est-ce que ce qui était attendu s'est produit ? », « Laquelle de ces situations s'est produite maintenant ? », « La solution appliquée a-t-elle aidé ? »
- Le nombre d'actions est de 1 de moins ou de plus que prévu. Solutions:
— augmenter la valeur initiale du compteur de 1.
— remplacez l'opérateur de comparaison strict (< ou >) par un opérateur non strict (<= ou >=).
— changer la valeur limite à 1. - Les actions en boucle sont effectuées sans arrêt, indéfiniment. Solutions:
— ajoutez une commande de changement de compteur si elle est manquante.
— corrigez la commande de changement de compteur pour que sa valeur se rapproche de la limite.
— supprimez la commande de changement de contrainte si elle se trouve dans le corps de la boucle. - Le nombre d'actions dans une boucle est supérieur ou égal à 1 de moins que prévu. L’action dans la boucle n’a pas été exécutée une seule fois. Vous devez d’abord connaître les valeurs réelles des variables juste avant le début de la boucle. Solutions:
— changer la valeur initiale de la contrainte
— changer la valeur initiale du compteur
Le problème 3 implique généralement d’utiliser la mauvaise variable ou de ne pas remettre le compteur à zéro.
Après cette explication, l’élève peut encore avoir diverses idées fausses sur le fonctionnement des boucles.
Pour dissiper les plus courantes, je vous confie les tâches suivantes :
- Dans lequel la limite, la valeur initiale du compteur ou le pas du compteur est saisi par l'utilisateur.
- Dans lequel la valeur du compteur doit être utilisée dans une expression arithmétique. Il est conseillé d'utiliser un compteur dans l'expression radicale ou dans le dénominateur pour que la différence soit non linéaire.
- Dans lequel la valeur du compteur n'est pas affichée à l'écran pendant l'exécution de la boucle. Par exemple, afficher le nombre requis de fragments de texte identiques ou dessiner une figure avec des graphiques de tortue.
- Dans lequel vous devez effectuer d'abord certaines actions répétitives, puis d'autres.
- Dans lequel vous devez effectuer d'autres actions avant et après la répétition
Pour chaque tâche, vous devez fournir des données de test et le résultat attendu.
Pour comprendre à quelle vitesse vous pouvez agir, vous devez lire les termes de ces problèmes et vous demander : « en quoi diffèrent-ils de l'exemple ? », « Que faut-il changer dans l'exemple pour les résoudre ? Si l'élève répond de manière significative, laissez-le en résoudre au moins une en classe et le reste à la maison par lui-même. Si la solution réussit, nous pouvons alors commencer à expliquer les conditions à l’intérieur des boucles.
Si vous avez du mal à résoudre des problèmes par vous-même, vous devez tout résoudre en classe. Pour éviter de résoudre le problème en faisant penser à dessiner un hibou, je recommande d'abord de résoudre le problème d'une manière non universelle. Autrement dit, pour que la solution réussisse le premier test et n'utilise pas la construction de boucle. Eh bien, appliquez ensuite des transformations pour atteindre l’universalité de la solution.
Boucles et branches
À mon avis, il est utile de traiter séparément le thème « cycles au sein des branches ». Pour que plus tard, vous puissiez voir la différence entre vérifier une condition plusieurs fois et la vérifier une seule fois.
Les tâches de consolidation consisteront à sortir des nombres de A à B, qui sont saisis par l'utilisateur :
- toujours par ordre croissant.
- croissant ou décroissant selon les valeurs de A et B.
Le thème du « branchement dans des boucles » ne doit être abordé qu'après que l'étudiant maîtrise les techniques : « remplacer un motif par une variable » et « remplacer des actions répétitives par un cycle ».
La principale raison de l’utilisation de branches à l’intérieur des boucles réside dans les anomalies du modèle. Au milieu, il se casse en fonction des données initiales.
Pour les étudiants qui sont capables de chercher une solution en combinant des techniques simples, il suffit de dire « les branchements peuvent être écrits à l'intérieur de boucles » et de donner le problème « par exemple » à résoudre complètement de manière indépendante.
Exemple de tâche :
L'utilisateur saisit le nombre X. Affichez les nombres de 0 à 9 dans une colonne et mettez un signe '+' en face du nombre égal à X.
Si 0 a été saisi0+
1
2
3
4
5
6
7
8
9
Si 6 a été saisi0
1
2
3
4
5
6+
7
8
9
Si 9 a été saisi0
1
2
3
4
5
6
7
8
9+
Si 777 a été saisi0
1
2
3
4
5
6
7
8
9
Si une brève explication ne suffit pas pour écrire avec une boucle, vous devez alors parvenir à une solution universelle au même problème sans boucle.
Vous aurez l'une des deux options suivantes :
Voulu
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);
}
Possible
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+");
}
Je donne une tâche similaire à l'avance, tout en étudiant le sujet du branchement.
Si l’élève propose une option « possible », vous devez alors lui dire qu’il peut y avoir plusieurs solutions au même problème. Cependant, ils diffèrent par leur résistance aux changements d’exigences. Posez la question : « Combien d’endroits dans le code faudrait-il corriger si je devais ajouter un autre numéro ? » Dans la version « possible », vous devrez ajouter une agence supplémentaire et ajouter un nouveau numéro à 10 autres endroits. Dans le « souhaité », il suffit d’ajouter une seule branche.
Définissez la tâche pour reproduire l'option « souhaitée », puis recherchez un modèle dans le code, effectuez un remplacement de variable et écrivez une boucle.
Si vous avez une idée sur la façon de résoudre ce problème sans boucle d'une autre manière, veuillez l'écrire dans les commentaires.
Boucles dans des boucles
Dans ce sujet, vous devez prêter attention aux éléments suivants :
— les compteurs des boucles interne et externe doivent être des variables différentes.
— le compteur de la boucle interne doit être réinitialisé plusieurs fois (c'est-à-dire dans le corps de la boucle externe).
— dans les tâches de sortie de texte, vous ne pouvez pas d'abord écrire une lettre sur plusieurs lignes, puis la seconde. Vous devez d'abord imprimer toutes les lettres de la première ligne, puis toutes les lettres de la seconde, et ainsi de suite.
Il est préférable de commencer à expliquer le sujet des boucles dans les boucles en expliquant l'importance de remettre le compteur à zéro.
Exemple de tâche :
L'utilisateur saisit deux nombres : R et T. Imprime deux lignes de caractères "#". La première ligne doit contenir des caractères R. La deuxième ligne contient des pièces en T. Si un nombre est négatif, affichez un message d’erreur.
R=5, T=11#####
###########
R=20, T=3########################
###
R=-1, T=6La valeur R doit être non négative
R=6, T=-2La valeur T doit être non négative
Évidemment, ce problème a aussi au moins deux solutions.
Voulu
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;
}
Possible #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;
}
La différence est que dans la solution « possible », une deuxième variable a été utilisée pour afficher la deuxième ligne. Vous devez insister pour utiliser la même variable pour les deux boucles. Cette limitation peut se justifier par le fait qu'une solution avec un compteur pour deux cycles sera une illustration du terme « remise à zéro du compteur ». Comprendre ce terme est nécessaire pour résoudre les problèmes suivants. À titre de compromis, vous pouvez enregistrer les deux solutions au problème.
Un problème typique lié à l'utilisation d'une variable de compteur pour deux boucles apparaît comme ceci :
R=5, T=11#####
######
Le nombre de caractères dans la deuxième ligne ne correspond pas à la valeur de T. Si vous avez besoin d'aide pour résoudre ce problème, vous devez consulter les notes sur les problèmes typiques liés aux boucles. C'est le symptôme n°3. Il est diagnostiqué si vous ajoutez une sortie de valeur de compteur juste avant le deuxième cycle. Corrigé par réinitialisation. Mais il vaut mieux ne pas le dire tout de suite. L'étudiant doit essayer de formuler au moins une hypothèse.
Il existe bien sûr une autre solution. Mais je n'ai jamais vu cela chez les étudiants. Au stade de l'étude des cycles, l'histoire à ce sujet détournera l'attention. Vous pourrez y revenir plus tard lorsque vous découvrirez les fonctions de chaîne.
Possible #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));
Tâche suivante requise :
Affichez les nombres de 0 à 9. Chaque nombre doit être sur sa propre ligne. Le nombre de chiffres dans une ligne (W) est saisi à partir du clavier.
W = 10
1
2
3
4
5
6
7
8
9
W = 100000000000
1111111111
2222222222
3333333333
4444444444
5555555555
6666666666
7777777777
8888888888
9999999999
Si un étudiant maîtrise la technique de remplacement d'une variable, il s'en sortira assez rapidement. Un problème possible sera à nouveau la réinitialisation de la variable. Si vous ne parvenez pas à gérer la transformation, cela signifie que vous étiez pressé et que vous devez résoudre des problèmes plus simples.
Merci pour votre attention. Aimez et abonnez-vous à la chaîne.
PS Si vous trouvez des fautes de frappe ou des erreurs dans le texte, faites-le moi savoir. Cela peut être fait en sélectionnant une partie du texte et en appuyant sur « ⌘ + Entrée » sur Mac, et « Ctrl/Entrée » sur les claviers classiques, ou via des messages privés. Si ces options ne sont pas disponibles, écrivez sur les erreurs dans les commentaires. Merci!
Seuls les utilisateurs enregistrés peuvent participer à l'enquête. s'il te plait.
Sondage pour les lecteurs sans karma
-
20,0%J'enseigne professionnellement, +12
-
10,0%J'enseigne professionnellement, -11
-
70,0%Je n'enseigne pas, +17
-
0,0%Je n'enseigne pas, -10
-
0,0%Autre (0
10 utilisateurs ont voté. 5 utilisateurs se sont abstenus.
Source: habr.com