{"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\/es\/blog\/kak-nauchit-preodolevat-trudnosti-a-zaodno-i-pisat-czikly","title":{"rendered":"C\u00f3mo ense\u00f1ar a superar dificultades y, de paso, a escribir ciclos","gt_translate_keys":[{"key":"rendered","format":"text"}]},"content":{"rendered":"

A pesar de que se trata de un tema b\u00e1sico, este art\u00edculo est\u00e1 dirigido a profesionales experimentados. Su objetivo es mostrar los conceptos err\u00f3neos que suelen tener los principiantes en programaci\u00f3n. Para los desarrolladores que ya est\u00e1n en pr\u00e1ctica, estos problemas se han resuelto hace tiempo, olvidados o pasados por alto. El art\u00edculo puede ser \u00fatil si en alg\u00fan momento necesitas ayudar a alguien con este tema. Se realizan paralelismos con material de varios libros de programaci\u00f3n escritos por Schildt, Stroustrup y Okulov.<\/p>\n

El tema sobre ciclos fue elegido porque es donde se filtra a muchas personas al iniciar en programaci\u00f3n.<\/p>\n

Este m\u00e9todo est\u00e1 dise\u00f1ado para estudiantes con dificultades. Generalmente, los estudiantes fuertes no se quedan atascados en este tema y no es necesario inventar m\u00e9todos especiales para ellos. Un objetivo secundario del art\u00edculo es trasladar este m\u00e9todo de la categor\u00eda \"funciona en todos los estudiantes, pero solo con un profesor\" a la categor\u00eda \"funciona para todos los estudiantes, todos los profesores\". No pretendo una originalidad absoluta. Si ya aplicas un m\u00e9todo similar para ense\u00f1ar este tema, por favor cu\u00e9ntame en qu\u00e9 se diferencia tu enfoque. Si decides aplicarlo, cu\u00e9ntame c\u00f3mo te fue al final. Si hay un m\u00e9todo similar descrito en alg\u00fan libro, por favor, ind\u00edcame el t\u00edtulo.<\/p>\n

<\/a><\/noindex>
\nEste m\u00e9todo lo he estado perfeccionando durante 4 a\u00f1os, trabajando individualmente con estudiantes de diferentes niveles. En total, alrededor de medio centenar de estudiantes y dos mil horas de clases. Al principio, los estudiantes se quedaban atascados en este tema y se iban. Con cada estudiante, el m\u00e9todo y los materiales se ajustaban. En el \u00faltimo a\u00f1o, los estudiantes ya no se quedan atascados en este tema, as\u00ed que decid\u00ed compartir mis hallazgos.<\/p>\n

\u00bfPor qu\u00e9 tantas letras? \u00a1Los ciclos son elementales!<\/h4>\n

\nComo mencion\u00e9 anteriormente, para desarrolladores en pr\u00e1ctica y para estudiantes fuertes, la complejidad del concepto de ciclos puede ser subestimada. Por ejemplo, se puede dar una larga conferencia, ver cabezas asintiendo y ojos inteligentes. Pero al intentar resolver alg\u00fan problema, comienza el bloqueo y surgen problemas inexplicables. Despu\u00e9s de la conferencia, los estudiantes probablemente solo tienen una comprensi\u00f3n parcial. La situaci\u00f3n se complica porque los estudiantes no pueden expresar por s\u00ed mismos en qu\u00e9 consiste exactamente su error.
\nUna vez me di cuenta de que los estudiantes perciben mis ejemplos como jerogl\u00edficos. Es decir, como fragmentos indivisibles de texto en los que hay que agregar alguna letra \"m\u00e1gica\" para que funcione.
\nA veces notaba que los estudiantes creen que para resolver un problema espec\u00edfico se necesita alguna otra<\/i> construcci\u00f3n que simplemente a\u00fan no les he explicado. Aunque para la soluci\u00f3n solo era necesario modificar un poco el ejemplo.<\/p>\n

Por lo tanto, llegu\u00e9 a la idea de que la atenci\u00f3n principal debe enfocarse no en la sintaxis de las expresiones, sino en la idea de refactorizar el c\u00f3digo repetitivo mediante bucles. Una vez que los alumnos dominan esta idea, cualquier sintaxis se adquiere con peque\u00f1os ejercicios.<\/p>\n

\u00bfA qui\u00e9n y por qu\u00e9 le ense\u00f1o?<\/h4>\n

\nDado que no hay ex\u00e1menes de ingreso, en las clases pueden haber tanto estudiantes fuertes como muy d\u00e9biles. Se puede leer m\u00e1s sobre mis estudiantes en el art\u00edculo Retrato de los oyentes de los cursos nocturnos<\/a><\/noindex>
\nMe esforc\u00e9 para que todos los que desean aprender programaci\u00f3n puedan hacerlo.
\nMis clases son individuales y el estudiante paga su dinero por cada una. Aparentemente, los estudiantes optimizar\u00edan sus costos y exigir\u00edan lo m\u00ednimo. Sin embargo, las personas asisten a clases presenciales con un docente no solo por el conocimiento en s\u00ed, sino por la confianza de haber comprendido, por la sensaci\u00f3n de progreso y por la aprobaci\u00f3n de un experto (el docente). Si los estudiantes no sienten que est\u00e1n progresando en su aprendizaje, se ir\u00e1n. En general, se pueden estructurar las clases de manera que los estudiantes sientan un progreso en la cantidad de construcciones familiares. Es decir, primero estudiamos a fondo while, luego for, despu\u00e9s do while y as\u00ed tenemos un curso de mil y una noches, donde durante dos meses estudiamos solo bucles, y al final hay un estudiante que escribi\u00f3 por dictado la biblioteca est\u00e1ndar. Sin embargo, para resolver problemas pr\u00e1cticos, se necesita no solo el conocimiento del material, sino tambi\u00e9n autonom\u00eda en su aplicaci\u00f3n y en la b\u00fasqueda de nueva informaci\u00f3n. Por lo tanto, considero correcto en los cursos presenciales el principio de ense\u00f1ar lo m\u00ednimo y fomentar el estudio autodidacta de matices y temas relacionados. En el tema sobre bucles, considero que el m\u00ednimo es la construcci\u00f3n while. Con eso se puede comprender el principio. Sabiendo el principio, se puede aprender for y do-while de forma aut\u00f3noma.<\/p>\n

Para lograr que los estudiantes m\u00e1s d\u00e9biles dominen el material, no basta con describir la sintaxis. Es necesario ofrecer m\u00e1s tareas simples, pero variadas, y detallar los ejemplos de manera m\u00e1s extensa. Al final, la velocidad de aprendizaje est\u00e1 limitada por la capacidad del estudiante para transformar las expresiones y encontrar patrones. Para los estudiantes m\u00e1s inteligentes, la mayor\u00eda de las tareas ser\u00e1n aburridas. Al trabajar con ellos, no es necesario insistir en resolver el 100% de los problemas. Pueden ver mi material en mi GitHub<\/a><\/noindex>. Aunque el repositorio se parece m\u00e1s a un grimorio de un hechicero; nadie, excepto yo, entender\u00e1 d\u00f3nde est\u00e1 cada cosa, y si se falla en la revisi\u00f3n, uno puede volverse loco.<\/p>\n

La metodolog\u00eda est\u00e1 orientada a la pr\u00e1ctica.<\/h4>\n

\nLa teor\u00eda se explica mediante la soluci\u00f3n de problemas. En las clases de fundamentos de programaci\u00f3n, donde se estudian bifurcaciones y ciclos, simplemente no se puede dar una conferencia \u00fatil sobre un solo tema durante una hora completa. Con 15-20 minutos es suficiente para explicar el concepto. Las principales dificultades surgen al realizar las tareas pr\u00e1cticas.
\nLos profesores principiantes pueden presentar operadores, bifurcaciones, ciclos y matrices en una sola lecci\u00f3n. Sin embargo, los estudiantes se enfrentar\u00e1n al problema de asimilar esta informaci\u00f3n.
\nNo solo hay que contar el material, sino tambi\u00e9n asegurarse de que los oyentes lo hayan entendido.<\/p>\n

El hecho de que un tema se haya asimilado se determina por c\u00f3mo el estudiante se enfrenta al trabajo aut\u00f3nomo.
\nSi el estudiante pudo resolver un problema sobre el tema sin la ayuda del profesor, significa que ha dominado el tema. Para facilitar la autoevaluaci\u00f3n, se describe una tabla con casos de prueba para cada tarea. Las tareas tienen un orden bien definido. No se recomienda saltarse tareas. Si la tarea actual es demasiado complicada, es in\u00fatil pasar a la siguiente; ser\u00e1 a\u00fan m\u00e1s dif\u00edcil. Para que el estudiante pueda afrontar la tarea complicada actual, se le explican algunos m\u00e9todos a partir del primer problema. De hecho, todo el contenido del tema se reduce a t\u00e9cnicas para superar las dificultades. Los ciclos son, m\u00e1s bien, un efecto secundario.<\/p>\n

La primera tarea siempre es un ejemplo. La segunda difiere ligeramente y se realiza 'por cuenta propia' inmediatamente despu\u00e9s de la primera bajo la supervisi\u00f3n del profesor. Todas las tareas posteriores est\u00e1n dirigidas a llamar la atenci\u00f3n sobre diferentes detalles que pueden causar confusiones.<\/p>\n

La explicaci\u00f3n del ejemplo es un di\u00e1logo en el que el estudiante necesita activar la retropropagaci\u00f3n y la validaci\u00f3n cruzada para asegurarse de haber comprendido la porci\u00f3n de material.<\/p>\n

Ser\u00e9 banal y dir\u00e9 que el primer ejemplo sobre el tema es muy importante. Si hay material para un extenso trabajo aut\u00f3nomo, las omisiones del primer ejemplo pueden ser corregidas. Si no hay nada m\u00e1s que el ejemplo, el estudiante probablemente no dominar\u00e1 el tema.<\/p>\n

\u00bfWhile o for?<\/h4>\n

\nUna de las cuestiones controversiales es la elecci\u00f3n de la estructura para el ejemplo: while o for. Una vez, un conocido m\u00edo, desarrollador pr\u00e1ctico sin experiencia en ense\u00f1anza, me convenci\u00f3 durante una hora de que el ciclo for es el m\u00e1s f\u00e1cil de entender. Sus argumentos se reduc\u00edan a 'todo est\u00e1 claro y organizado'. Sin embargo, la verdadera causa de las dificultades para los aut\u00e9nticos principiantes radica en la idea del ciclo, no en su escritura. Si una persona no comprende esta idea, tendr\u00e1 problemas con la sintaxis. Tan pronto como la idea es entendida, los problemas con la redacci\u00f3n del c\u00f3digo desaparecen.<\/p>\n

En mis materiales, el tema de los ciclos sigue al tema de las ramificaciones. La similitud externa entre if y while permite hacer una analog\u00eda directa: 'cuando la condici\u00f3n en el encabezado es verdadera, se ejecuta el cuerpo'. La particularidad del ciclo es que el cuerpo se ejecuta varias veces.<\/p>\n

Mi segundo argumento es que while requiere menos formato que for. Menos formato significa menos errores tontos con comas y par\u00e9ntesis omitidos. Los principiantes a\u00fan no han desarrollado suficiente atenci\u00f3n y minuciosidad para evitar autom\u00e1ticamente los errores de sintaxis.
\nEl tercer argumento es que en muchos buenos libros, while se explica primero.<\/p>\n

Si el estudiante puede transformar expresiones f\u00e1cilmente, se puede hablar de for de manera incidental. Luego el estudiante elegir\u00e1 lo que m\u00e1s le guste. Sin embargo, si las transformaciones son problem\u00e1ticas, es mejor no distraer la atenci\u00f3n. Primero que el estudiante resuelva todo con while. Cuando haya asimilado el tema de los ciclos, se pueden reescribir las soluciones para trabajar la transformaci\u00f3n de while a for.
\nLos ciclos con condici\u00f3n al final son bastante raros. No pierdo tiempo en ellos en absoluto. Si el estudiante ha dominado las ideas de identificar patrones y transformar expresiones, podr\u00e1 entenderlo sin mi ayuda.<\/p>\n

Al presentar el primer ejemplo a estudiantes avanzados, enfatizo que en el primer ejemplo es importante documentar no solo la soluci\u00f3n, sino tambi\u00e9n toda la cadena de acciones que llevaron al resultado. Los estudiantes perezosos pueden despreciar la escritura y simplemente trasladar el algoritmo final. Hay que convencerlos de que en alg\u00fan momento se encontrar\u00e1n con un problema complejo. Para resolverlo, ser\u00e1 necesario seguir los pasos como en este ejemplo. Por eso es crucial documentar todas las etapas. En los siguientes problemas, se podr\u00e1 dejar solo la versi\u00f3n final de la soluci\u00f3n.<\/p>\n

La idea principal de la automatizaci\u00f3n es que delegamos al computador la realizaci\u00f3n del trabajo rutinario en lugar de hacerlo nosotros. Uno de los enfoques b\u00e1sicos es la escritura de bucles. Se utiliza cuando en el programa se escriben varias acciones id\u00e9nticas y repetitivas de forma consecutiva.<\/p>\n

Lo expl\u00edcito es mejor que lo impl\u00edcito<\/h4>\n

\nPuede parecer una buena idea en el primer ejercicio sobre bucles mostrar en pantalla la misma frase varias veces. Por ejemplo:<\/p>\n

\u00a1Hurra, funciona!
\n\u00a1Hurra, funciona!
\n\u00a1Hurra, funciona!
\n\u00a1Hurra, funciona!
\n\u00a1Hurra, funciona!
\n\u00a1Hurra, funciona!
\n\u00a1Hurra, funciona!
\n\u00a1Hurra, funciona!\n<\/p><\/blockquote>\n

\nEsta opci\u00f3n es mala porque en la salida no se ve el valor del contador. Este es un problema para los principiantes. No deber\u00edamos subestimarlo. Originalmente, esta tarea era la primera, y la tarea sobre la salida de una serie de n\u00fameros en orden ascendente era la segunda. Ten\u00eda que introducir t\u00e9rminos adicionales como 'bucle N veces' y 'bucle de A a B', que en esencia son lo mismo. Para no crear entidades innecesarias, decid\u00ed mostrar solo el ejemplo de salida de una serie de n\u00fameros. A pocos les resulta f\u00e1cil aprender a mantener un contador en la mente y modelar el comportamiento del programa mentalmente. Algunos estudiantes se encuentran por primera vez con la modelaci\u00f3n 'en la mente' precisamente en el tema de bucles.
\nDespu\u00e9s de cierta pr\u00e1ctica, asigno la tarea de repetir un texto id\u00e9ntico para que se resuelva de manera independiente. Si primero se muestra un contador visible y luego uno invisible, los estudiantes tienen menos problemas. A veces, es suficiente con la sugerencia 'no escribas el contador en la pantalla'.<\/p>\n

\u00bfC\u00f3mo se explica en otros lugares?<\/h4>\n

\nEn la mayor\u00eda de los materiales de aprendizaje en internet, la sintaxis del ciclo se presenta como parte de una 'lecci\u00f3n'. Por ejemplo, en developer.mozilla.org (en este momento), junto con el ciclo while se describen varias otras construcciones. Sin embargo, se dan exclusivamente las construcciones mismas en forma de plantillas. Los resultados de su ejecuci\u00f3n se describen con palabras, y no hay ilustraci\u00f3n. En mi opini\u00f3n, esta forma de presentar el tema reduce a cero la utilidad de tales materiales. Un estudiante puede copiar el c\u00f3digo y ejecutarlo por s\u00ed mismo, pero a\u00fan necesita un est\u00e1ndar para comparar. \u00bfC\u00f3mo puede saber que el ejemplo se ha reescrito correctamente si no tiene con qu\u00e9 comparar el resultado?
\nCuando solo se proporciona una plantilla, sin un ejemplo, se vuelve a\u00fan m\u00e1s dif\u00edcil para el estudiante. \u00bfC\u00f3mo puede saber que los fragmentos de c\u00f3digo est\u00e1n colocados correctamente en la plantilla? Se puede intentar escribir de alguna manera<\/i>, y luego ejecutarlo. Pero si no hay un est\u00e1ndar para comparar el resultado, entonces ejecutar tampoco ayudar\u00e1.<\/p>\n

En el curso de C++ en el que estoy, la sintaxis del ciclo est\u00e1 oculta en la tercera p\u00e1gina de la lecci\u00f3n 4 sobre el tema \u00aboperadores\u00bb. Al explicar la sintaxis de los ciclos, se hace un \u00e9nfasis particular en el t\u00e9rmino \u00aboperador\u00bb. El t\u00e9rmino se presenta como un conjunto de hechos como \u00abel s\u00edmbolo; es un operador\u00bb, \u00ab{} es un operador compuesto\u00bb, \u00abel cuerpo del ciclo debe ser un operador\u00bb. No me gusta este enfoque porque oculta las importantes interconexiones tras un solo t\u00e9rmino. El an\u00e1lisis del c\u00f3digo fuente a este nivel es necesario para los desarrolladores de compiladores que implementan la especificaci\u00f3n del lenguaje, pero no para estudiantes en su primer acercamiento. Los principiantes en programaci\u00f3n rara vez tienen la minuciosidad suficiente para prestar tanta atenci\u00f3n a los t\u00e9rminos. Rara vez una persona recuerda y comprende nuevas palabras a la primera. Pr\u00e1cticamente nadie puede aplicar correctamente un t\u00e9rmino que acaba de aprender. Por eso, los estudiantes cometen numerosos errores como \u00abescrib\u00ed while(a<7);{, pero el programa no funciona\u00bb.
\nEn mi opini\u00f3n, al principio es mejor ense\u00f1ar la sintaxis de la construcci\u00f3n inmediatamente con los corchetes. La variante sin corchetes debe explicarse solo si el estudiante plantea una pregunta concreta '\u00bfpor qu\u00e9 aqu\u00ed sin corchetes y funciona?'.<\/p>\n

En el libro de Okulov \u00abFundamentos de la programaci\u00f3n\u00bb de 2012, la introducci\u00f3n a los ciclos comienza con la plantilla for, luego se dan recomendaciones para su uso, y despu\u00e9s se presenta inmediatamente una secci\u00f3n experimental de la clase. Entiendo que el libro fue escrito para esa minor\u00eda de alumnos muy talentosos que raramente vienen a mis clases.<\/p>\n

En los libros populares siempre se incluye el resultado de fragmentos de c\u00f3digo. Por ejemplo, en el libro de Schildt \u00abJava 8. Gu\u00eda completa\u00bb de 2015. Primero se presenta la plantilla, luego un ejemplo de programa y justo despu\u00e9s el resultado de su ejecuci\u00f3n.<\/p>\n

Como ejemplo, consideremos el ciclo while, en el que se realiza una cuenta regresiva
\ncomenzando desde 10, y se imprimen exactamente 10 l\u00edneas de \u2018tictacs\u2019: <\/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
\nAl ejecutarse, este programa muestra diez \u2018tictacs\u2019 de la siguiente manera:
\nt\u00e1ctica 10
\nt\u00e1ctica 9
\nt\u00e1ctica 8
\nt\u00e1ctica 7
\nt\u00e1ctica 6
\nt\u00e1ctica 5
\nt\u00e1ctica 4
\nt\u00e1ctica 3
\nt\u00e1ctica 2
\nt\u00e1ctica 1<\/code><\/p><\/blockquote>\n
\nEl enfoque que describe la plantilla, el ejemplo de programa y el resultado de la ejecuci\u00f3n tambi\u00e9n se utiliza en el libro \u00abJavaScript para ni\u00f1os\u00bb y en el curso de js en w3schools.com. El formato de la p\u00e1gina web incluso permite hacer este ejemplo interactivo.<\/p>\n
En el libro de Stroustrup \u00abPrincipios y pr\u00e1ctica utilizando C++\u00bb de 2016, el autor va a\u00fan m\u00e1s lejos. Primero se explica qu\u00e9 resultado se debe obtener, y despu\u00e9s se muestra el texto del programa. Adem\u00e1s, como ejemplo, no se elige simplemente un programa al azar, sino que se ofrece una excursi\u00f3n por la historia. Esto ayuda a captar su atenci\u00f3n: \u2018Mira, esto no es solo un texto in\u00fatil. Ves algo significativo.\u2019<\/p>\n
Como ejemplo de iteraci\u00f3n, consideremos el primer programa ejecutado en una m\u00e1quina de programa almacenado (EDSAC). Fue escrito por David Wheeler en el laboratorio de computaci\u00f3n de la Universidad de Cambridge (Cambridge University, Inglaterra) el 6 de mayo de 1949. Este programa calcula e imprime una simple lista de cuadrados.
\n0 0
\n1 1
\n2 4
\n3 9
\n4 16
\n...
\n98 9604
\n99 9801<\/code>
\nAqu\u00ed, en cada l\u00ednea hay un n\u00famero seguido de un tabulador (\u2018t\u2019) y el cuadrado de ese n\u00famero. La versi\u00f3n de este programa en C++ es as\u00ed:<\/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
\nCuriosamente, el patr\u00f3n de sintaxis en este libro no se describe. Stroustrup, en la gu\u00eda del instructor (la traducci\u00f3n<\/a><\/noindex>) enfatiza que respeta la inteligencia de sus estudiantes. Tal vez la habilidad de identificar un patr\u00f3n en varios ejemplos se considera una manifestaci\u00f3n de esa inteligencia.<\/p>\n
Como lo explico yo mismo<\/h4>\n
\nEl enfoque de Stroustrup: describir el resultado, luego resolver el problema y, por \u00faltimo, un an\u00e1lisis independiente por parte del estudiante, parece ser el m\u00e1s reflexivo. Por eso decid\u00ed tomarlo como base, pero contar sobre un ejemplo menos hist\u00f3rico: el problema de generar un \"\u00edndice\". Este crea un ancla reconocible para poder decir m\u00e1s tarde \"recuerda el problema del \u00edndice\" y para que los estudiantes lo recuerden exactamente. En mi ejemplo intent\u00e9 anticipar otros dos de los conceptos err\u00f3neos m\u00e1s comunes. A continuaci\u00f3n, escribir\u00e9 sobre ellos en m\u00e1s detalle.<\/p>\n
En este ejercicio, nos familiarizamos con las t\u00e9cnicas para resolver problemas complejos. La soluci\u00f3n inicial debe ser primitiva y sencilla. Luego se puede pensar en c\u00f3mo mejorar esta soluci\u00f3n.
\nIntroducci\u00f3n
\nCap\u00edtulo 1
\nCap\u00edtulo 2
\nCap\u00edtulo 3
\nCap\u00edtulo 4
\nCap\u00edtulo 5
\nCap\u00edtulo 6
\nCap\u00edtulo 7
\nConclusi\u00f3n<\/code><\/p><\/blockquote>\n
\nSeg\u00fan mis observaciones, el enfoque \u00abplantilla-ejemplo-resultado\u00bb en diferentes combinaciones lleva a que los estudiantes perciban el ciclo como un jerogl\u00edfico. Esto se manifestaba en que no entend\u00edan por qu\u00e9 era necesario escribir una condici\u00f3n, c\u00f3mo elegir entre i++ e i-- y otras cosas que, a primera vista, parecen obvias. Para evitar estas confusiones, el enfoque para hablar sobre ciclos debe enfatizar el sentido de repetir acciones id\u00e9nticas y solo despu\u00e9s la formalizaci\u00f3n a trav\u00e9s de la construcci\u00f3n. Por lo tanto, antes de dar la sintaxis del ciclo, se debe resolver el problema \u00abdirectamente\u00bb. Una soluci\u00f3n primitiva al problema sobre el \u00edndice de contenido es as\u00ed:<\/p>\n
Console.WriteLine(\"Introducci\u00f3n\");\nConsole.WriteLine(\"Cap\u00edtulo 1\");\nConsole.WriteLine(\"Cap\u00edtulo 2\");\nConsole.WriteLine(\"Cap\u00edtulo 3\");\nConsole.WriteLine(\"Cap\u00edtulo 4\");\nConsole.WriteLine(\"Cap\u00edtulo 5\");\nConsole.WriteLine(\"Cap\u00edtulo 6\");\nConsole.WriteLine(\"Cap\u00edtulo 7\");\nConsole.WriteLine(\"Conclusi\u00f3n\");\n<\/code><\/pre>\n
\n\u00bfC\u00f3mo se puede mejorar?
\nSustituir las acciones repetitivas por un ciclo.
\n\u00bfQu\u00e9 acciones se repiten aqu\u00ed de forma consecutiva y sin cambios?
\nEn este fragmento no hay tales acciones. Sin embargo, los comandos para imprimir la palabra \"Cap\u00edtulo\" con el n\u00famero son muy similares entre s\u00ed.
\nPor lo tanto, el siguiente paso es buscar la diferencia entre los fragmentos. Solo en este ejercicio todo es obvio, luego no se repetir\u00e1n solo comandos individuales, sino bloques de c\u00f3digo de 5 l\u00edneas o m\u00e1s. La b\u00fasqueda tendr\u00e1 que hacerse no solo en la lista de comandos, sino tambi\u00e9n en las estructuras de bifurcaci\u00f3n o ciclo.
\nEn el ejemplo, la diferencia entre los comandos est\u00e1 en el n\u00famero despu\u00e9s de la palabra \"Cap\u00edtulo\".
\nUna vez que se haya encontrado la diferencia, es necesario entender la regularidad del cambio. \u00bfEs el fragmento diferente un n\u00famero? \u00bfAumenta o disminuye constantemente? \u00bfC\u00f3mo cambia el valor del n\u00famero entre dos comandos uno al lado del otro?
\nEn el ejemplo, el n\u00famero despu\u00e9s de la palabra 'Cap\u00edtulo' aumenta en pasos de 1. Se ha encontrado una diferencia, se ha identificado un patr\u00f3n. Ahora se puede reemplazar el fragmento variable por una variable.
\nSe debe declarar dicha variable antes de la primera de las partes que se repiten. Esta variable suele llamarse i o j, o de forma m\u00e1s extensa. Su valor inicial debe ser igual al primer valor que se muestra en pantalla. En el ejemplo, el primer valor es 1. 
\n\u00bfQu\u00e9 valor inicial se debe tomar para mostrar la secuencia de n\u00fameros '100, 101, 102, 103, 104, 105'?
\nEn esta secuencia, el primer n\u00famero es 100.
\nDespu\u00e9s de cada comando de salida, es necesario incrementar el valor de esta variable en 1. Esta unidad es el paso de cambio.
\n\u00bfCu\u00e1l ser\u00e1 el paso en la secuencia de n\u00fameros '100, 102, 104, 106'?
\nEn esta secuencia, el paso es 2.
\nDespu\u00e9s de reemplazar el fragmento variable por una variable, el c\u00f3digo se ver\u00e1 as\u00ed:<\/p>\n
Console.WriteLine(\"Introducci\u00f3n\");\nint i;\ni = 0;\nConsole.WriteLine(\"Cap\u00edtulo \" + i);\ni = i + 1;\nConsole.WriteLine(\"Cap\u00edtulo \" + i);\ni = i + 1;\nConsole.WriteLine(\"Cap\u00edtulo \" + i);\ni = i + 1;\nConsole.WriteLine(\"Cap\u00edtulo \" + i);\ni = i + 1;\nConsole.WriteLine(\"Cap\u00edtulo \" + i);\ni = i + 1;\nConsole.WriteLine(\"Cap\u00edtulo \" + i);\ni = i + 1;\nConsole.WriteLine(\"Cap\u00edtulo \" + i);\ni = i + 1;\nConsole.WriteLine(\"Conclusi\u00f3n\");\n<\/code><\/pre>\n
\nDespu\u00e9s de aplicar la t\u00e9cnica 'expresar el patr\u00f3n como una variable', el c\u00f3digo tiene varios grupos de acciones id\u00e9nticas que se ejecutan una tras otra. Ahora, las acciones repetidas se pueden reemplazar por un bucle.<\/p>\n
La secuencia para resolver el problema, donde es necesario usar bucles, consta de las etapas:<\/p>\n
    \n
  1. Resolver 'de manera directa' con m\u00faltiples comandos individuales.<\/li>\n
  2. Encontrar un patr\u00f3n.<\/li>\n
  3. Expresar el patr\u00f3n como una variable.<\/li>\n
  4. Formatear en forma de bucle.<\/li>\n<\/ol>\n
    A continuaci\u00f3n se introducen nuevos t\u00e9rminos para que el estudiante no se encuentre en la situaci\u00f3n de 'entiendo todo, pero no puedo expresarlo':
    \n \u2014 contador: siempre es una variable que se necesita para rastrear la cantidad de pasos del bucle. Generalmente es un n\u00famero entero, que se compara con un l\u00edmite.
    \n \u2014 paso del contador: descripci\u00f3n del patr\u00f3n de cambio del contador.
    \n \u2014 l\u00edmite: n\u00famero o variable con la que se compara el contador para que el algoritmo sea finito. El valor del contador cambia para acercarse al l\u00edmite.
    \n \u2014 cuerpo del bucle: conjunto de comandos que se repetir\u00e1n. Cuando se dice 'comando escrito dentro del bucle', se refiere precisamente al cuerpo.
    \n \u2014 iteraci\u00f3n del bucle: ejecuci\u00f3n \u00fanica del cuerpo del bucle.
    \n \u2014 condici\u00f3n del ciclo \u2014 expresi\u00f3n l\u00f3gica de la que depende si se ejecutar\u00e1 otra iteraci\u00f3n. (Aqu\u00ed puede haber confusi\u00f3n con las estructuras de ramificaci\u00f3n)
    \nEs importante estar preparado para que al principio los estudiantes utilicen los t\u00e9rminos incorrectamente. Esto se aplica tanto a los estudiantes fuertes como a los d\u00e9biles. Establecer un lenguaje com\u00fan es todo un arte. Ahora lo dir\u00e9 brevemente: hay que plantear la tarea 'destaca el fragmento de c\u00f3digo con ' y usar estos t\u00e9rminos correctamente en la conversaci\u00f3n.
    \nDespu\u00e9s de la transformaci\u00f3n con el ciclo, se obtiene el fragmento:<\/p>\n
    Console.WriteLine(\"Introducci\u00f3n\");\nint i = 0;\nwhile (i < 7) {\n    Console.WriteLine("Cap\u00edtulo " + i);\n    i = i + 1;\n}\nConsole.WriteLine("Conclusi\u00f3n");<\/code><\/pre>\n
    La principal confusi\u00f3n<\/h4>\n
    \nUna confusi\u00f3n popular entre los estudiantes es que colocan dentro de la estructura del ciclo acciones que deben realizarse solo una vez. Por ejemplo, as\u00ed:<\/p>\n
    ;\nint i = 0;\nwhile (i < 7) {\n    Console.WriteLine("Introducci\u00f3n")\n    Console.WriteLine("Cap\u00edtulo " + i);\n    i = i + 1;\n    Console.WriteLine("Conclusi\u00f3n");\n}\n<\/code><\/pre>\n
    \nLos alumnos se encuentran constantemente con este problema, tanto al principio como en tareas m\u00e1s complejas.
    \nConsejo clave en este caso:<\/p>\n
    \u00bfCu\u00e1ntas veces se necesita repetir el comando: una vez o muchas?\n<\/p><\/blockquote>\n
    \nLos comandos para mostrar las palabras 'Introducci\u00f3n' y 'Conclusi\u00f3n', as\u00ed como la declaraci\u00f3n e inicializaci\u00f3n de la variable i, no son como otras acciones repetitivas. Se ejecutan solo una vez, por lo que deben estar fuera del cuerpo del ciclo.<\/p>\n
    El c\u00f3digo debe contener las tres etapas de la soluci\u00f3n, para que luego se puedan referir a ellas en caso de dificultades. Los dos primeros casos se pueden comentar para que no molesten.
    \nLa atenci\u00f3n del estudiante debe centrarse en los siguientes hechos:
    \n \u2014 En la condici\u00f3n del ciclo generalmente se compara el contador y el l\u00edmite. El contador puede cambiar dentro del cuerpo del ciclo, pero el l\u00edmite no. Para violar esta regla, se necesitan razones de peso.
    \n \u2014 Los comandos para mostrar las palabras 'Introducci\u00f3n' y 'Conclusi\u00f3n' est\u00e1n fuera del cuerpo del ciclo. Debemos ejecutarlos 1 vez. 'Introducci\u00f3n' \u2014 antes de repetir las acciones, 'Conclusi\u00f3n' \u2014 despu\u00e9s.
    \nAl consolidar este tema, en el dominio de los pr\u00f3ximos, as\u00ed como al lidiar con dificultades, es \u00fatil incluso para los estudiantes fuertes plantear la pregunta: '\u00bfY esta acci\u00f3n cu\u00e1ntas veces hay que realizarla? \u00bfUna o muchas?'.<\/p>\n
    Desarrollo de habilidades adicionales<\/h4>\n
    \nEn el proceso de estudio de los ciclos, los estudiantes tambi\u00e9n practican la habilidad de diagn\u00f3stico y resoluci\u00f3n de problemas. Para llevar a cabo el diagn\u00f3stico, el estudiante necesita imaginar el resultado deseado y compararlo con el resultado real. Las acciones para corregir dependen de la diferencia entre ellos.
    \nDado que los estudiantes en esta etapa todav\u00eda tienen una noci\u00f3n vaga del \"resultado deseado\", pueden orientarse en funci\u00f3n de los datos de prueba. Por lo general, nadie en este punto entiende qu\u00e9 podr\u00eda salir mal y c\u00f3mo lidiar con ello. Por eso, hago que apunten en su cuaderno una descripci\u00f3n de los problemas t\u00edpicos y varias maneras de resolverlos. La elecci\u00f3n de la m\u00e1s adecuada es tarea del propio estudiante.
    \nSe necesita el registro para preguntar: \"\u00bfse logr\u00f3 lo que se esperaba?\", \"\u00bfCu\u00e1l de estas situaciones se ha dado ahora?\", \"\u00bfAyud\u00f3 la soluci\u00f3n aplicada?\".<\/p>\n
      \n
    1. La cantidad de acciones es 1 menos o m\u00e1s de lo esperado. M\u00e9todos de soluci\u00f3n:
      \n \u2014 aumentar el valor inicial del contador en 1.
      \n \u2014 reemplazar el operador de comparaci\u00f3n estricta () por uno no estricto (=).
      \n \u2014 cambiar el valor del l\u00edmite en 1.<\/li>\n
    2. Las acciones en el ciclo se ejecutan sin parar, infinitamente. M\u00e9todos de soluci\u00f3n:
      \n \u2014 agregar un comando para modificar el contador, si falta.
      \n \u2014 corregir el comando para modificar el contador de modo que su valor se acerque al l\u00edmite.
      \n \u2014 eliminar el comando de modificaci\u00f3n del l\u00edmite, si est\u00e1 en el cuerpo del ciclo.<\/li>\n
    3. La cantidad de acciones en el ciclo es m\u00e1s de 1 menos o m\u00e1s de lo esperado. La acci\u00f3n en el ciclo no se ejecut\u00f3 ni una vez. Primero, es necesario averiguar los valores reales de las variables inmediatamente antes del inicio del ciclo. M\u00e9todos de soluci\u00f3n:
      \n \u2014 cambiar el valor inicial del l\u00edmite
      \n \u2014 cambiar el valor inicial del contador<\/li>\n<\/ol>\n
      \nGeneralmente, el problema 3 est\u00e1 relacionado con el uso de la variable incorrecta o con no reiniciar el contador.<\/p>\n
      Despu\u00e9s de esta explicaci\u00f3n, el estudiante a\u00fan puede tener diversos malentendidos sobre el funcionamiento de los ciclos.
      \nPara disipar los m\u00e1s comunes, propongo tareas:<\/p>\n
        \n
      1. En la que el l\u00edmite, el valor inicial del contador o el paso del contador son introducidos por el usuario.<\/li>\n
      2. En la que se necesita utilizar el valor del contador en alguna expresi\u00f3n aritm\u00e9tica. Preferiblemente, que el contador est\u00e9 en el sub-expresion o en el denominador, de modo que la diferencia sea no lineal.<\/li>\n
      3. En el que el valor del contador no se muestra en la pantalla durante el ciclo. Por ejemplo, mostrar una cantidad necesaria de fragmentos de texto id\u00e9nticos o dibujar una figura usando gr\u00e1ficos tortuga.<\/li>\n
      4. En el que primero se deben realizar unas acciones repetitivas y luego otras.<\/li>\n
      5. En el que se deben realizar otras acciones antes y despu\u00e9s de las repetitivas.<\/li>\n<\/ol>\n
        \nPara cada tarea, es necesario proporcionar datos de prueba y el resultado esperado.<\/p>\n
        Para entender cu\u00e1n r\u00e1pido se puede avanzar, es necesario leer las condiciones de estas tareas y preguntar: \u00ab\u00bfen qu\u00e9 se diferencian del ejemplo?\u00bb, \u00ab\u00bfqu\u00e9 hay que cambiar en el ejemplo para resolverlas?\u00bb. Si el estudiante responde de manera reflexiva, entonces debe resolver al menos una en la clase, y las dem\u00e1s en casa por su cuenta. Si la soluci\u00f3n es exitosa, se puede comenzar con la explicaci\u00f3n sobre las condiciones dentro de los ciclos.
        \nSi hay dificultades con la resoluci\u00f3n aut\u00f3noma, se debe trabajar todo en clase. Para que la soluci\u00f3n del problema no se asemeje a dibujar un b\u00faho, recomiendo primero resolver el problema de manera no universal. Es decir, de tal manera que la soluci\u00f3n pase la primera prueba y no utilice la estructura del ciclo. Luego, se aplicar\u00e1n transformaciones para lograr la universalidad de la soluci\u00f3n.<\/p>\n
        Ciclos y bifurcaciones<\/h4>\n
        \nEn mi opini\u00f3n, es \u00fatil tratar el tema \u00abciclos dentro de bifurcaciones\u00bb por separado. As\u00ed, luego se podr\u00e1 ver la diferencia entre verificar la condici\u00f3n varias veces y hacerlo una sola vez.
        \nLas tareas para fijar el conocimiento ser\u00e1n sobre la salida de n\u00fameros del A al B, que son introducidos por el usuario:
        \n \u2014 siempre en orden ascendente.
        \n \u2014 en orden ascendente o descendente dependiendo de los valores de A y B.<\/p>\n
        El tema \"ramificaci\u00f3n dentro de ciclos\" solo debe ser abordado una vez que el estudiante haya dominado las t\u00e9cnicas: \"sustituci\u00f3n de patrones por variables\" y \"sustituci\u00f3n de acciones repetitivas por ciclos\".
        \nLa principal raz\u00f3n para aplicar bifurcaciones dentro de ciclos son las anomal\u00edas en el patr\u00f3n. En medio, se interrumpe dependiendo de los datos de entrada.
        \nPara aquellos estudiantes que pueden buscar soluciones combinando t\u00e9cnicas simples, basta con decir \u00ablas bifurcaciones se pueden escribir dentro de los ciclos\u00bb y dar una tarea \u00abcomo ejemplo\u00bb completamente para soluci\u00f3n aut\u00f3noma.
        \nTarea de ejemplo:<\/p>\n
        El usuario ingresa un n\u00famero X. Imprimir en una columna los n\u00fameros del 0 al 9 y colocar el signo \u2018+\u2019 frente al n\u00famero que sea igual a X.<\/p><\/blockquote>\n
        \nSi se ha introducido 0<\/b>0+
        \n1
        \n2
        \n3
        \n4
        \n5
        \n6
        \n7
        \n8
        \n9<\/p>\n
        Si se ingres\u00f3 6<\/b>0
        \n1
        \n2
        \n3
        \n4
        \n5
        \n6+
        \n7
        \n8
        \n9<\/p>\n
        Si se ingres\u00f3 9<\/b>0
        \n1
        \n2
        \n3
        \n4
        \n5
        \n6
        \n7
        \n8
        \n9+<\/p>\n
        Si se ingres\u00f3 777<\/b>0
        \n1
        \n2
        \n3
        \n4
        \n5
        \n6
        \n7
        \n8
        \n9<\/p>\n
        Si la explicaci\u00f3n breve no es suficiente para escribir con un ciclo, entonces se debe lograr una soluci\u00f3n universal para la misma tarea sin ciclo.
        \nObtendr\u00e1 una de dos opciones:
        \nDeseado<\/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
        Posible<\/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
        Un problema similar lo doy con anticipaci\u00f3n, durante el estudio del tema sobre ramificaciones.
        \nSi el estudiante obtuvo una opci\u00f3n 'posible', debe explicarse que para el mismo problema puede haber m\u00faltiples soluciones. Sin embargo, estas difieren en su resistencia a los cambios de requisitos. Pregunte: \"\u00bfCu\u00e1ntos lugares en el c\u00f3digo necesitar\u00edan ser corregidos si tuvi\u00e9ramos que agregar otro n\u00famero?\" En la opci\u00f3n 'posible' ser\u00eda necesario agregar otra ramificaci\u00f3n y escribir el nuevo n\u00famero en 10 lugares m\u00e1s. En la 'deseada' solo es suficiente a\u00f1adir una ramificaci\u00f3n.
        \nPlantee la tarea de reproducir la opci\u00f3n 'deseada', luego encuentre el patr\u00f3n en el c\u00f3digo, realice el reemplazo de la variable y escriba el ciclo.
        \nSi tiene una idea sobre c\u00f3mo resolver este problema sin un ciclo de otra manera, por favor escr\u00edbalo en los comentarios.<\/p>\n
        Ciclos dentro de ciclos<\/h4>\n
        \nEn este tema, es importante prestar atenci\u00f3n a lo siguiente:
        \n \u2014 los contadores del ciclo interno y externo deben ser diferentes variables.
        \n \u2014 el contador del ciclo interno debe reiniciarse muchas veces (es decir, en el cuerpo del ciclo externo).
        \n En las tareas de salida de texto, no se puede escribir una letra en varias l\u00edneas y luego escribir la siguiente. Primero hay que mostrar todas las letras de la primera l\u00ednea, luego todas las letras de la segunda, y as\u00ed sucesivamente.<\/p>\n
        La explicaci\u00f3n del tema sobre ciclos dentro de ciclos es mejor comenzar explicando la importancia de reiniciar el contador.
        \nTarea de ejemplo:<\/p>\n
        El usuario ingresa dos n\u00fameros: R y T. Imprimir dos l\u00edneas de caracteres \"#\". En la primera l\u00ednea debe haber R caracteres. En la segunda l\u00ednea, T caracteres. Si alg\u00fan n\u00famero es negativo, mostrar un mensaje de error.<\/p><\/blockquote>\n
        \nR=5, T=11<\/b>#####
        \n###########<\/p>\n
        R=20, T=3<\/b>####################
        \n###<\/p>\n
        R=-1, T=6<\/b>El valor de R debe ser no negativo.<\/p>\n
        R=6, T=-2<\/b>El valor de T debe ser no negativo.<\/p>\n
        Es evidente que este problema tambi\u00e9n tiene al menos dos variantes de soluci\u00f3n.
        \nDeseado<\/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
        Posible \u21161<\/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
        La diferencia es que en la soluci\u00f3n \"posible\" se utiliz\u00f3 una segunda variable para mostrar la segunda l\u00ednea. Es necesario insistir en el uso de la misma variable para ambos ciclos. Se puede argumentar que una soluci\u00f3n con un solo contador para dos ciclos ilustrar\u00e1 el t\u00e9rmino \"reinicio del contador\". Comprender este t\u00e9rmino es necesario para resolver problemas posteriores. Como compromiso, se pueden mantener ambas soluciones del problema.<\/p>\n
        Un problema t\u00edpico al utilizar una variable contador para dos ciclos se manifiesta as\u00ed:
        \nR=5, T=11<\/b>#####
        \n######<\/p>\n
        La cantidad de caracteres en la segunda l\u00ednea no corresponde al valor de T. Si se necesita ayuda con este problema, se debe \"plantar\" en el resumen sobre los problemas t\u00edpicos con los ciclos. Este es el s\u00edntoma \u21163. Se diagnostica si se a\u00f1ade la salida del valor del contador justo antes del segundo ciclo. Se corrige reiniciando. Pero es mejor no contar esto de inmediato. El estudiante debe intentar formular al menos una hip\u00f3tesis.<\/p>\n
        Por supuesto, tambi\u00e9n hay otra variante de soluci\u00f3n. Pero nunca la he visto en los estudiantes. En la etapa de estudio de los ciclos, hablar de ello distraer\u00e1 la atenci\u00f3n. Se puede volver a ello m\u00e1s tarde, al estudiar las funciones de manipulaci\u00f3n de cadenas.
        \nPosible \u21162<\/b><\/p>\n
        cadena 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
        \nLa siguiente tarea obligatoria:<\/p>\n
        Imprima en pantalla los n\u00fameros del 0 al 9. Cada n\u00famero debe estar en su propia l\u00ednea. La cantidad de n\u00fameros en la l\u00ednea (W) se introduce desde el teclado.<\/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
        Si el estudiante ha dominado el m\u00e9todo de reemplazo de variables, lo har\u00e1 bastante r\u00e1pido. El posible problema ser\u00e1 de nuevo la inicializaci\u00f3n de la variable. Si no logra hacer la conversi\u00f3n, significa que se ha apresurado y necesita resolver problemas m\u00e1s simples.<\/p>\n
        Gracias por su atenci\u00f3n. Den me gusta, suscr\u00edbanse al canal.<\/p>\n
        P.D. Si encontr\u00f3 errores tipogr\u00e1ficos o errores en el texto, por favor h\u00e1ganmelo saber. Puede hacerlo seleccionando parte del texto y presionando en Mac \u00ab\u2318 + Enter\u00bb, y en teclados cl\u00e1sicos \u00abCtrl \/ Enter\u00bb, o a trav\u00e9s de mensajes personales. Si estas opciones no est\u00e1n disponibles, escriba sobre los errores en los comentarios. \u00a1Gracias!<\/p>\n
        Solo los usuarios registrados pueden participar en la encuesta. Inicie sesi\u00f3n<\/a><\/noindex>, por favor.<\/p>\n
        Encuesta para lectores sin karma<\/h2>\n