איך ללמד איך להתגבר על קשיים, ובמקביל לכתוב מחזורים

למרות העובדה שנדבר על אחד מהנושאים הבסיסיים, מאמר זה נכתב עבור אנשי מקצוע מנוסים. המטרה היא להראות אילו תפיסות שגויות יש למתחילים בתכנות. עבור מפתחים מתרגלים, בעיות אלו נפתרו מזמן, נשכחו או לא שמו לב כלל. המאמר עשוי להיות שימושי אם אתה פתאום צריך לעזור למישהו בנושא זה. המאמר מקביל לחומר מספרים שונים על תכנות מאת Schildt, Stroustrup, Okulov.

הנושא על מחזורים נבחר מכיוון שדי הרבה אנשים אינם נכללים ממנו בעת שליטה בתכנות.

טכניקה זו מיועדת לתלמידים חלשים. ככלל, אנשים חזקים לא נתקעים בנושא זה ואין צורך להמציא טכניקות מיוחדות עבורם. המטרה המשנית של המאמר היא להעביר טכניקה זו מכיתת "עובד לכל התלמידים, אבל רק מורה אחד" לכיתת "עובד לכל התלמידים, כל המורים". אני לא טוען למקוריות מוחלטת. אם אתה כבר משתמש במתודולוגיה דומה כדי ללמד נושא זה, אנא כתוב כיצד הגרסה שלך שונה. אם תחליט להשתמש בו, ספר לנו איך זה הלך. אם טכניקה דומה מתוארת בספר, נא לכתוב את השם.

עבדתי על טכניקה זו במשך 4 שנים, ולמדתי באופן אינדיבידואלי עם תלמידים ברמות אימון שונות. בסך הכל יש כחמישים תלמידים ואלפיים שעות שיעורים. בהתחלה, תלמידים תמיד נתקעו בנושא הזה ועזבו. לאחר כל תלמיד הותאמו המתודולוגיה והחומרים. במהלך השנה האחרונה, התלמידים כבר לא היו תקועים בנושא הזה, אז החלטתי לשתף את הממצאים שלי.

למה כל כך הרבה מכתבים? מחזורים הם כל כך אלמנטריים!

כפי שכתבתי למעלה, למפתחים מתרגלים ולסטודנטים חזקים, ניתן לזלזל במורכבות המושג לולאות. למשל, אפשר לתת הרצאה ארוכה, לראות ראשים מהנהנים ועיניים אינטליגנטיות. אבל כשמנסים לפתור כל בעיה, מתחילות קהות חושים ובעיות בלתי מוסברות. לאחר ההרצאה, לסטודנטים הייתה כנראה הבנה חלקית בלבד. המצב מחמיר בשל העובדה שהתלמידים עצמם אינם יכולים להשמיע מהי בדיוק האשליה שלהם.
יום אחד הבנתי שתלמידים תופסים את הדוגמאות שלי כהירוגליפים. כלומר, כמו פיסות טקסט בלתי ניתנות לחלוקה שבהן אתה צריך להוסיף איזו אות "קסם" וזה יעבוד.
לפעמים שמתי לב שתלמידים חושבים שכדי לפתור בעיה ספציפית אתה צריך משהו אחר עיצוב שפשוט לא כיסיתי עדיין. למרות שהפתרון דרש רק שינוי קל של הדוגמה.

אז הגעתי לרעיון שהפוקוס לא צריך להיות בתחביר של ביטויים, אלא ברעיון של הפקת קוד חוזר באמצעות לולאות. לאחר שהתלמידים שולטים ברעיון זה, ניתן לשפר כל תחביר עם מעט תרגול.

את מי ולמה אני מלמד?

מכיוון שאין מבחני כניסה, השיעורים יכולים לכלול תלמידים חזקים וחלשים מאוד. תוכל לקרוא עוד על התלמידים שלי במאמר דיוקן תלמידי קורס ערב
השתדלתי להבטיח שכל מי שרוצה ללמוד תכנות יוכל ללמוד זאת.
השיעורים שלי מתקיימים בנפרד והתלמיד משלם את כספו עבור כל אחד מהם. נראה שהסטודנטים יבצעו אופטימיזציה של עלויות וידרשו את המינימום. עם זאת, אנשים הולכים לשיעורים פנים אל פנים עם מורה חי לא בשביל הידע עצמו, אלא בשביל הביטחון של מה שלמדו, בשביל הרגשה של התקדמות וקבלת אישור מהמומחה (המורה). אם התלמידים לא ירגישו התקדמות בלמידה שלהם, הם יעזבו. באופן כללי, ניתן לבנות את השיעורים כך שהתלמידים ירגישו התקדמות בהגדלת מספר המבנים המוכרים. כלומר, קודם לומדים תוך כדי לפרטים, אחר כך לומדים, אחר כך עושים תוך כדי, ועכשיו יש לנו קורס אלף ולילה מוכן, שבו לומדים מחזורים בלבד במשך חודשיים, ובסוף - סטודנט שכתב. ספרייה סטנדרטית בהכתבה. עם זאת, כדי לפתור בעיות מעשיות, אתה צריך לא רק ידע בחומר, אלא גם עצמאות ביישומו ובחיפוש אחר מידע חדש. לכן, עבור קורסים פנים אל פנים, אני חושב שהעיקרון הנכון הוא ללמד את המינימום ולעודד לימוד עצמאי של ניואנסים ונושאים קשורים. בנושא לולאות, אני מחשיב את מבנה ה-while כמינימום. אפשר להבין ממנו את העיקרון. הכרת העיקרון, אתה יכול לשלוט גם בשביל וגם לעשות תוך כדי עצמך.

כדי להשיג שליטה בחומר על ידי תלמידים חלשים, תיאור התחביר אינו מספיק. יש צורך לתת משימות פשוטות יותר אך מגוונות ולתאר דוגמאות ביתר פירוט. בסופו של דבר, מהירות ההתפתחות מוגבלת על ידי יכולתו של התלמיד לשנות ביטויים ולחפש דפוסים. עבור תלמידים חכמים, רוב המטלות יהיו משעממות. כשאתה לומד איתם, אתה לא צריך להתעקש לפתור 100% מהבעיות. ניתן לראות את החומר שלי בכתובת ה-github שלי. נכון, המאגר הוא יותר כמו grimoire של קוסם - אף אחד מלבדי לא יבין מה נמצא איפה, ואם תיכשל בצ'ק, אתה יכול להשתגע

המתודולוגיה מוכוונת פרקטיקה

התיאוריה מוסברת באמצעות הדוגמה של פתרון בעיה. בשיעור יסודות של תכנות בו מלמדים ענפים ולופים, פשוט לא ניתן לתת הרצאה שימושית בנושא אחד במשך שעה שלמה. 15-20 דקות מספיקות כדי להסביר את הרעיון. הקשיים העיקריים מתעוררים בעת ביצוע משימות מעשיות.
מורים מתחילים יכולים לקשקש מפעילים, ענפים, לולאות ומערכים בהרצאה אחת. אבל התלמידים שלהם יתמודדו עם הבעיה של הטמעת המידע הזה.
יש צורך לא רק לספר את החומר, אלא גם לוודא שהשומעים מבינים אותו.

עובדת השליטה בנושא נקבעת על ידי האופן שבו התלמיד מתמודד עם עבודה עצמאית.
אם תלמיד הצליח לפתור בעיה בנושא ללא עזרה של מורה, אז הנושא השתלט. כדי להבטיח בדיקה עצמית, כל משימה מתוארת בטבלה עם תרחישי בדיקה. למשימות יש סדר ברור. לא מומלץ לדלג על משימות. אם המשימה הנוכחית קשה מדי, אז המעבר למשימה הבאה הוא חסר תועלת. זה אפילו יותר מסובך. כדי שהתלמיד יוכל לשלוט במשימה המורכבת הנוכחית, מוסברות לו מספר טכניקות באמצעות הדוגמה של הבעיה הראשונה. למעשה, כל התוכן של הנושא מסתכם בטכניקות להתגברות על קשיים. מחזורים הם יותר תופעת לוואי.

המשימה הראשונה היא תמיד דוגמה. השני שונה מעט ומתבצע "באופן עצמאי" מיד לאחר הראשון בהשגחת מורה. כל המשימות הבאות מכוונות לשים לב לדברים קטנים שונים שיכולים לגרום לתפיסות שגויות.

ההסבר של הדוגמה הוא דיאלוג שבו התלמיד צריך להתקשר בחזרה להפצה ולאימות צולב כדי לוודא שהוא שולט בחלק מהחומר.

אני אהיה בנאלי ואומר שהדוגמה הראשונה בנושא חשובה מאוד. אם יש לך את החומר לעבודה עצמאית נרחבת, ניתן לתקן את ההשמטות של הדוגמה הראשונה. אם אין שום דבר אחר מלבד הדוגמה, סביר להניח שהתלמיד לא ישלוט בנושא.

תוך כדי או עבור?

אחת הסוגיות השנויות במחלוקת היא בחירת הבנייה לדוגמא: תוך כדי או בעד. פעם אחת, ידידי מפתח מתאמן ללא ניסיון בהוראה בילה שעה בשכנע אותי שלולאת ה-for היא הקלה ביותר להבנה. הטיעונים הסתכמו ב"הכל בו ברור ומוצב במקומו". עם זאת, הסיבה העיקרית לקשיים למתחילים אמיתיים היא הרעיון של המחזור עצמו, ולא הכתיבה שלו. אם אדם לא מבין את הרעיון הזה, אז הוא יתקשה עם התחביר. ברגע שהרעיון מתממש, הבעיות של עיצוב הקוד נעלמות מעצמן.

בחומרים שלי, הנושא של לולאות עוקב אחר נושא ההסתעפות. הדמיון החיצוני של if ו-while מאפשר לנו לשרטט אנלוגיה ישירה: "כאשר התנאי בכותרת נכון, אז הגוף מבוצע." המוזרות היחידה של המחזור היא שהגוף מבוצע פעמים רבות.

הטיעון השני שלי הוא ש-while דורש פחות עיצוב מאשר עבור. פחות עיצוב פירושו פחות טעויות מטופשות עם פסיקים וסוגריים חסרים. מתחילים עדיין לא פיתחו מספיק קשב והקפדה כדי להימנע אוטומטית משגיאות תחביר.
הטיעון השלישי מוסבר בספרים טובים רבים כטיעון הראשון.

אם התלמיד יכול בקלות לשנות ביטויים, אז אתה יכול לדבר על זה בדרך אגב. לאחר מכן התלמיד יבחר את מה שהוא הכי אוהב. אם טרנספורמציות גורמות לקשיים, אז עדיף לא להסיח את תשומת הלב שלך. תן לתלמיד לפתור תחילה הכל באמצעות תוך כדי. לאחר שתשלוט בנושא לולאות, תוכל לשכתב את הפתרונות כדי לתרגל המרה תוך כדי.
לולאות Postcondition הן חיה די נדירה. אני לא מבזבז זמן על זה בכלל. אם תלמיד שולט ברעיונות של זיהוי דפוסים ושינוי ביטויים, הוא יכול להבין זאת ללא עזרתי.

בהדגמת הדוגמה הראשונה לתלמידים חזקים, אני מפנה את תשומת הלב לכך שבדוגמה הראשונה חשוב לרשום לא רק את הפתרון, אלא גם את כל שרשרת הפעולות שהובילה לתוצאה. תלמידים עצלנים יכולים להזניח את הכתיבה ולהעתיק רק את האלגוריתם הסופי. הם צריכים להיות משוכנעים שיום אחד משימה קשה תקרה בדרכם. כדי לפתור אותה, תצטרך לבצע את השלבים כמו בדוגמה זו. לכן חשוב לרשום את כל השלבים. בבעיות הבאות ניתן יהיה להשאיר רק את הגרסה הסופית של הפתרון.

הרעיון המרכזי של אוטומציה הוא שאנו מפקידים על מחשב לבצע עבודה שגרתית עבור אדם. אחת הטכניקות הבסיסיות היא כתיבת לולאות. הוא משמש כאשר מספר פעולות חוזרות זהות נכתבות בתוכנית ברצף.

מפורש עדיף על מרומז

זה אולי נראה כמו רעיון טוב להציג את אותו ביטוי מספר פעמים במשימת הלולאה הראשונה. לדוגמה:

היי, זה עובד!
היי, זה עובד!
היי, זה עובד!
היי, זה עובד!
היי, זה עובד!
היי, זה עובד!
היי, זה עובד!
היי, זה עובד!

אפשרות זו גרועה מכיוון שערך המונה אינו גלוי בפלט. זו בעיה למתחילים. אל תזלזל בה. בתחילה, משימה זו הייתה הראשונה, והמשימה של גזירת סדרה של מספרים בסדר עולה הייתה השנייה. היה צורך להציג מונחים נוספים "מחזור N פעמים" ו"מחזור מ-A ל-B", שהם בעצם אותו דבר. כדי לא ליצור ישויות מיותרות, החלטתי להציג רק דוגמה עם פלט של סדרת מספרים. מעטים האנשים שמצליחים ללמוד איך להחזיק מונה בראש ולדגמן התנהגות של תוכנית בראשם ללא הכנה. חלק מהתלמידים נתקלים לראשונה בדוגמנות מחשבתית בנושא מחזוריות.
לאחר קצת תרגול, אני נותן את המשימה לחזור על אותו טקסט כדי להיפתר באופן עצמאי. אם תיתן תחילה מונה גלוי ואחר כך בלתי נראה, לתלמידים יהיו פחות בעיות. לפעמים הרמז "אל תכתוב את המונה על המסך" מספיק.

איך אחרים מסבירים את זה?

ברוב החומרים הלימודיים באינטרנט, תחביר המחזור ניתן במסגרת "הרצאה". לדוגמה, ב-Developer.mozilla.org (נכון לעכשיו), מספר מבנים אחרים מתוארים יחד עם לולאת while. במקרה זה, רק העיצובים עצמם ניתנים בצורה של תבניות. התוצאה של השקתם מתוארת במילים, אך אין המחשה. לדעתי, הצגה כזו של הנושא מכפילה את התועלת של חומרים כאלה באפס. התלמיד יכול לשכתב את הקוד ולהריץ אותו בעצמו, אבל הוא עדיין צריך תקן להשוואה. איך אפשר להבין שדוגמה נכתבה מחדש נכון אם אין מה להשוות את התוצאה?
כאשר ניתנת רק תבנית, ללא דוגמה, זה נהיה קשה עוד יותר עבור התלמיד. איך להבין שקטעי הקוד ממוקמים נכון בתבנית? אתה יכול לנסות לכתוב איכשהו, ואז לרוץ. אבל אם אין תקן להשוואת התוצאה, אז גם ההשקה לא תעזור.

בקורס C++ בנושא אינטואיטיבי, תחביר הלולאה קבור בעמוד השלישי של הרצאה 4 בנושא "מפעילים". כאשר מסבירים את התחביר של לולאות, מושם דגש מיוחד על המונח "מפעיל". המונח מוצג כמערכת של עובדות כמו "סמל; זה משפט", "{} הוא משפט מורכב", "גוף הלולאה חייב להיות משפט". אני לא אוהב את הגישה הזו כי נראה שהיא מסתירה מערכות יחסים חשובות מאחורי מונח אחד. ניתוח קוד המקור של תוכנית למונחים ברמה זו נדרש על ידי מפתחי מהדרים כדי ליישם את מפרט השפה, אך לא על ידי תלמידים כקירוב ראשון. מצטרפים חדשים לתכנות לעתים נדירות מספיק קפדניים כדי להקדיש תשומת לב כל כך למונחים. זה אדם נדיר שזוכר ומבין מילים חדשות בפעם הראשונה. כמעט אף אחד לא יכול ליישם נכון מונח שלמד זה עתה. לכן, תלמידים מקבלים הרבה שגיאות כמו "כתבתי while(a<7);{, אבל התוכנית לא עובדת."
לדעתי, בהתחלה עדיף לתת את התחביר של הבנייה מיד עם סוגריים. יש להסביר את האפשרות ללא סוגריים רק אם לתלמיד יש שאלה ספציפית: "למה אין סוגריים וזה עובד".

בספר "יסודות התכנות" של אוקולוב משנת 2012, מבוא ללולאות מתחיל בדפוס for, לאחר מכן נותן המלצות לשימוש בו, ומיד עובר לחלק הניסיוני של השיעור. אני מבין שהספר נכתב עבור אותו מיעוט של תלמידים מוכשרים שממעטים להגיע לשיעורים שלי.

בספרים פופולריים, התוצאה של שברי קוד כתובה תמיד. לדוגמה, "Java 8. The Complete Guide" של שילדט מהדורת 2015. ראשית, ניתנת תבנית, לאחר מכן תוכנית לדוגמה ומיד אחריה - תוצאת הביצוע.

כדוגמה, שקול לולאת while שעושה הפוך
ספירה לאחור מתחילה מ-10, ומוצגות בדיוק 10 שורות של "מדידות":

//Продемонстрировать применение оператора цикла while
class While {
    public static void main(String args []) {
        int n = 10;
        while (n > 0) {
            System.out.println("такт " + n);
            n--;
        }
    }
}

לאחר ההפעלה, תוכנית זו מפיקה עשרה "מחזורים" באופן הבא:
такт 10
такт 9
такт 8
такт 7
такт 6
такт 5
такт 4
такт 3
такт 2
такт 1

הגישה של תיאור תבנית, תוכנית לדוגמה ותוצאת התוכנית משמשת גם בספר "Javascript for Kids" ובקורס js באתר w3schools.com. פורמט דף האינטרנט אפילו מאפשר לדוגמא זו להיות אינטראקטיבית.

ספרו של Stroustrup משנת 2016 עקרונות ותרגול שימוש ב-C++ הרחיק עוד יותר. השלב הראשון הוא להסביר איזו תוצאה יש להשיג, ולאחר מכן מוצג הטקסט של התוכנית. יתר על כן, הם לוקחים לא רק תוכנית אקראית כדוגמה, אלא נותנים סיור להיסטוריה. זה עוזר למשוך את תשומת הלב אליו: "תראה, זה לא סתם איזה טקסט חסר תועלת. אתה רואה משהו משמעותי".

כדוגמה לאיטרציה, שקול את התוכנית הראשונה שבוצעה במכונה מאוחסנת (EDSAC). הוא נכתב על ידי דיוויד ווילר במעבדת המחשבים של אוניברסיטת קיימברידג', אנגליה ב-6 במאי 1949. תוכנית זו מחשבת ומדפיסה רשימה פשוטה של ​​ריבועים.
0 0
1 1
2 4
3 9
4 16
...
98 9604
99 9801
כאן, כל שורה מכילה מספר ואחריו תו טאב ('t') ואת הריבוע של מספר זה. גרסת C++ של תוכנית זו נראית כך:

//Вычисляем и распечатываем таблицу квадратов чисел 0-99
int main()
{
    int i = 0; // Начинаем с нуля
    while(i < 100){
        cout << i << 't' << square(i) << 'n';
        ++i;
    }
}

מעניין שדפוס התחביר אינו מתואר בספר זה. סטרוסטרופ במדריך למדריך (תרגום) מדגישה כי היא מכבדת את האינטליגנציה של תלמידיה. אולי היכולת לזהות דפוס במספר דוגמאות נחשבת לביטוי של אינטליגנציה כזו.

כפי שאני מסביר את עצמי

הגישה של שטרוסטרופ: תיאור התוצאה, לאחר מכן פתרון הבעיה, ולאחר מכן ניתוח עצמאי על ידי התלמיד - נראית המתחשבת ביותר. לכן, החלטתי לקחת את זה כבסיס, אבל לספר זאת באמצעות דוגמה פחות היסטורית - המשימה של גזירת "תוכן עניינים". זה יוצר עוגן שניתן לזהות, כך שתוכל לומר אז "זכור את המשימה לגבי תוכן העניינים" וכדי שהתלמידים יזכרו בדיוק את זה. בדוגמה שלי, ניסיתי למנוע עוד שתיים מהתפיסות השגויות הנפוצות ביותר. בהמשך אכתוב עליהם ביתר פירוט.

במשימה זו אנו מתוודעים לטכניקות לפתרון בעיות מורכבות. ההחלטה הראשונית צריכה להיעשות פרימיטיבית ופשוטה. ובכן, אז אתה יכול לחשוב איך לשפר את הפתרון הזה.
Введение
Глава 1
Глава 2
Глава 3
Глава 4
Глава 5
Глава 6
Глава 7
Заключение

לפי התצפיות שלי, גישת "תבנית-דוגמה-תוצאה" בשילובים שונים עדיין מובילה לכך שתלמידים תופסים את המחזור כהירוגליף. זה התבטא בכך שהם לא הבינו למה יש תנאי לכתוב שם, איך לבחור בין i++ ל-i— ועוד דברים לכאורה ברורים. כדי למנוע תפיסות שגויות אלו, הגישה לדבר על מחזוריות צריכה להדגיש את המשמעות של חזרה על פעולות זהות ורק לאחר מכן פורמלתן באמצעות מבנה. לכן, לפני מתן תחביר הלולאה, עליך לפתור את הבעיה חזיתית. פתרון פרימיטיבי לבעיית תוכן העניינים נראה כך:

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("Заключение");

איך אפשר לשפר?
החלף פעולות מונוטוניות במחזור.
אילו פעולות חוזרות על עצמן ברצף ללא שינויים?
אין כאלה בפרגמנט הזה. עם זאת, הפקודות להצגת המילה "פרק" עם מספר דומות מאוד זו לזו.
לכן, השלב הבא הוא למצוא את ההבדל בין השברים. רק במשימה הזו הכל ברור, אז לא יחזרו על פקודות בודדות, אלא בלוקים של קוד של 5 שורות או יותר. תצטרך לחפש לא רק ברשימת הפקודות, אלא במבני הסתעפות או לולאות.
בדוגמה, ההבדל בין הפקודות הוא במספר שאחרי המילה "פרק".
ברגע שנמצא ההבדל, אתה צריך להבין את דפוס השינוי. השבר השונה הוא המספר? האם זה כל הזמן עולה או יורד? כיצד משתנה הערך של מספר בין שתי קבוצות זו לצד זו?
בדוגמה, המספר אחרי המילה "פרק" גדל במרווחים של 1. נמצא ההבדל, הדפוס מתגלה. כעת אתה יכול להחליף את הפרגמנט השונה במשתנה.
אתה צריך להכריז על משתנה כזה לפני הראשון מבין השברים החוזרים. משתנה כזה נקרא בדרך כלל I או j או משהו מפורט יותר. הערך ההתחלתי שלו חייב להיות שווה לערך הראשון המוצג על המסך. בדוגמה, הערך הראשון הוא 1.
איזה ערך התחלתי צריך לקחת כדי להציג את סדרת המספרים "100, 101, 102, 103, 104, 105"?
המספר הראשון בסדרה זו הוא 100.
לאחר כל פקודת פלט, עליך להגדיל את הערך של משתנה זה ב-1. יחידה זו היא שלב השינוי.
איזה שלב יהיה בסדרת המספרים "100, 102, 104, 106"?
שלב 2 בשורה זו.
לאחר החלפת הפרגמנט השונה במשתנה, הקוד ייראה כך:

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("Заключение");

לאחר יישום הטכניקה "להביע את התבנית של משתנה" בקוד, אתה מקבל מספר קבוצות של פעולות זהות שהולכות ברצף. כעת ניתן להחליף פעולות חוזרות במחזור.

רצף פתרון הבעיה שבה אתה צריך להשתמש בלולאות מורכב מהשלבים הבאים:

1. פתרו "חזיתית" עם הרבה פקודות נפרדות
2. מצא דפוס
3. הביעו את התבנית של משתנה
4. עיצוב כמחזור

לאחר מכן, מוצגים מונחים חדשים כדי שהתלמיד לא ימצא את עצמו במצב של "אני מבין הכל, אבל אני לא יכול להגיד את זה":
- מונה הוא תמיד משתנה הדרוש כדי לעקוב אחר מספר השלבים בלולאה. בדרך כלל מספר שלם שמשווה לאילוץ.
— צעד נגדי — תיאור דפוס השינויים במונה.
- אילוץ - מספר או משתנה שאיתם המונה מושווה כך שהאלגוריתם יהיה סופי. ערך המונה משתנה כדי להתקרב לגבול.
— גוף לולאה — קבוצה של פקודות שיחזרו על עצמן. כשהם אומרים "הפקודה כתובה בתוך לולאה", הם מתכוונים לגוף.
— איטרציה של לולאה — ביצוע חד פעמי של גוף הלולאה.
— תנאי לולאה — ביטוי לוגי שקובע אם איטרציה נוספת תתבצע. (ייתכן שיש בלבול עם מבנים מסועפים כאן)
אתה צריך להיות מוכן לעובדה שבהתחלה התלמידים ישתמשו במונחים למטרות אחרות. זה תקף גם לחזקים וגם לחלשים. הקמת שפה משותפת היא אמנות. עכשיו אני אכתוב בקצרה: אתה צריך להגדיר את המשימה "הדגש את קטע הקוד עם <term>" ולהשתמש במונחים אלה בעצמך בצורה נכונה בשיחה.
לאחר טרנספורמציה עם לולאה, השבר מתקבל:

Console.WriteLine("Введение");
int i = 0;
while (i < 7) {
    Console.WriteLine("Глава " + i);
    i = i + 1;
}
Console.WriteLine("Заключение");

הטעות העיקרית

תפיסה מוטעית אחת פופולרית בקרב תלמידים היא שהם ממקמים פעולות בתוך לולאה שצריך לעשות רק פעם אחת. למשל ככה:

;
int i = 0;
while (i < 7) {
    Console.WriteLine("Введение")
    Console.WriteLine("Глава " + i);
    i = i + 1;
    Console.WriteLine("Заключение");
}

תלמידים נתקלים בבעיה זו כל הזמן, גם בהתחלה וגם בבעיות מורכבות יותר.
רמז מרכזי במקרה זה:

כמה פעמים צריך לחזור על הפקודה: פעם אחת או הרבה פעמים?

הפקודות להדפסת המילים "מבוא" ו"מסקנה" והכרזה ואתחול של המשתנה i אינן דומות לפעולות שחוזרות על עצמן. הם מבוצעים פעם אחת בלבד, מה שאומר שהם צריכים להיכתב מחוץ לגוף הלולאה.

כל שלושת השלבים של הפתרון צריכים להישאר בקוד כדי שתוכל להתייחס אליהם מאוחר יותר במקרה של קשיים. מספיק להעיר את שתי האפשרויות הראשונות כדי שלא יפריעו.
יש להפנות את תשומת לב התלמיד לעובדות הבאות:
- במצב לולאה, בדרך כלל משווים מונה וגבול. המונה יכול להשתנות בגוף הלולאה, אבל הגבול לא יכול. כדי לשבור את הכלל הזה, עליך לנסח סיבות משכנעות.
- פקודות להצגת המילים "מבוא" ו"מסקנה" ממוקמות מחוץ לגוף הלולאה. אנחנו צריכים לבצע אותם פעם אחת. "מבוא" - לפני חזרה על הפעולות, "מסקנה" - אחרי.
בתהליך של איחוד נושא זה, שליטה בנושאים הבאים, כמו גם התמודדות עם קשיים, כדאי אפילו לתלמידים חזקים לשאול את השאלה: "כמה פעמים צריך לבצע את הפעולה הזו? אחד או רבים?

פיתוח מיומנויות נוספות

בתהליך לימוד המחזורים מפתחים התלמידים גם מיומנות אבחון ופתרון בעיות. כדי לבצע אבחון, התלמיד צריך להציג את התוצאה הרצויה ולהשוות אותה לתוצאה בפועל. פעולות תיקון תלויות בהבדל ביניהן.
מכיוון שלתלמידים בשלב זה עדיין אין מושג לגבי התוצאה ה"רצויה", הם יכולים להתמקד בנתוני המבחן. ככלל, אף אחד בשלב זה עדיין לא מבין מה יכול להשתבש ואיך להתמודד עם זה. לכן, אני כותב במחברת תיאור של בעיות טיפוסיות ומספר דרכים לפתור אותן. בחירת המתאים ביותר היא המשימה של התלמיד עצמו.
יש צורך ברישום כדי לשאול "האם מה שהיה צפוי קרה?", "איזה מהמצבים האלה קרה עכשיו?", "האם הפתרון היישומי עזר?"

1. מספר הפעולות הוא 1 פחות או יותר מהצפוי. פתרונות:
   - הגדל את הערך ההתחלתי של המונה ב-1.
   — החלף את אופרטור ההשוואה הקפדנית (< או >) באופרטור לא קפדני (<= או >=).
   - שנה את ערך הגבול ל-1.
2. פעולות בלולאה מבוצעות ללא עצירה, ללא הגבלת זמן. פתרונות:
   - הוסף פקודת שינוי מונה אם היא חסרה.
   - תקן את פקודת שינוי המונה כך שהערך שלה יתקרב לגבול.
   - הסר את פקודת שינוי אילוץ אם היא נמצאת בגוף הלולאה.
3. מספר הפעולות בלולאה הוא יותר מ-1 פחות או יותר מהצפוי. הפעולה בלופ לא בוצעה אפילו פעם אחת. ראשית עליך לברר את הערכים האמיתיים של המשתנים רגע לפני שהלולאה מתחילה. פתרונות:
   - שנה את הערך ההתחלתי של האילוץ
   - שנה את הערך ההתחלתי של המונה

בעיה 3 בדרך כלל כוללת שימוש במשתנה הלא נכון או אי איפוס המונה לאפס.

לאחר הסבר זה, לתלמיד עדיין עשויות להיות תפיסות שגויות שונות לגבי אופן הפעולה של לולאות.
כדי להפיג את המשימות הנפוצות ביותר, אני נותן לך את המשימות הבאות:

1. שבו הגבול, ערך המונה הראשוני או צעד המונה מוזנים על ידי המשתמש.
2. שבו יש להשתמש בערך המונה בביטוי אריתמטי כלשהו. רצוי להשתמש במונה בביטוי הרדיקלי או במכנה כדי שההבדל יהיה לא ליניארי.
3. שבו ערך המונה אינו מוצג על המסך בזמן שהלולאה פועלת. לדוגמה, הצגת המספר הנדרש של שברי טקסט זהים או ציור דמות עם גרפיקה של צב.
4. שבו אתה צריך לבצע תחילה כמה פעולות חוזרות, ואחר כך אחרות.
5. שבו אתה צריך לבצע פעולות אחרות לפני ואחרי חזרה

עבור כל משימה אתה צריך לספק נתוני בדיקה ואת התוצאה הצפויה.

כדי להבין כמה מהר אתה יכול לזוז, אתה צריך לקרוא את המונחים של בעיות אלה ולשאול: "במה הן שונות מהדוגמה?", "מה צריך לשנות בדוגמה כדי לפתור אותן?" אם התלמיד עונה בצורה משמעותית, אז תן לו לפתור לפחות אחד בכיתה, ואת השאר בבית בעצמו. אם הפתרון מצליח, אז נוכל להתחיל להסביר את התנאים בתוך הלולאות.
אם יש לך בעיות בפתרון בעיות בעצמך, אתה צריך לעבוד על הכל בכיתה. כדי למנוע שפתרון הבעיה יזכיר ציור ינשוף, אני ממליץ קודם כל לפתור את הבעיה בצורה לא אוניברסלית. כלומר, כדי שהפתרון יעבור את המבחן הראשון ולא ישתמש בבניית הלולאה. ובכן, אז החל טרנספורמציות כדי להשיג אוניברסליות של הפתרון.

לולאות וענפים

לדעתי, כדאי לתת את הנושא "מחזורים בתוך ענפים" בנפרד. כך שבהמשך תוכלו לראות את ההבדל בין בדיקת מצב מספר פעמים לבדיקתו פעם אחת.
המשימות לאיחוד יהיו על הפלט של מספרים מ-A עד B, המוזנים על ידי המשתמש:
- תמיד בסדר עולה.
- עולה או יורד בהתאם לערכים של A ו-B.

יש להעביר את הנושא של "הסתעפות בתוך לולאות" רק לאחר שהתלמיד שולט בטכניקות: "החלפת תבנית במשתנה" ו"החלפת פעולות חוזרות במחזור".
הסיבה העיקרית לשימוש בענפים בתוך לולאות היא חריגות בתבנית. באמצע זה נשבר בהתאם לנתונים הראשוניים.
לאותם תלמידים שמסוגלים לחפש פתרון בשילוב טכניקות פשוטות, מספיק לומר "ניתן לכתוב הסתעפות בתוך לולאות" ולתת לבעיה "לדוגמה" לחלוטין לפתור באופן עצמאי.
משימה לדוגמה:

המשתמש מזין את המספר X. הצג את המספרים מ-0 עד 9 בעמודה ושם סימן '+' מול המספר השווה ל-X.

אם הוזן 00+
1
2
3
4
5
6
7
8
9

אם הוזן 60
1
2
3
4
5
6+
7
8
9

אם הוזן 90
1
2
3
4
5
6
7
8
9+

אם הוזן 7770
1
2
3
4
5
6
7
8
9

אם הסבר קצר לא מספיק כדי לכתוב עם לולאה, אז אתה צריך להשיג פתרון אוניברסלי לאותה בעיה ללא לולאה.
תקבל אחת משתי אפשרויות:
רצוי

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);
}

אפשרי

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+");
}

אני נותן משימה דומה מראש, תוך כדי לימוד נושא ההסתעפות.
אם התלמיד מעלה אפשרות "אפשרית", אז אתה צריך להגיד לו שיכולים להיות פתרונות רבים לאותה בעיה. עם זאת, הם שונים בעמידותם לשינויים בדרישות. שאל את השאלה: "כמה מקומות בקוד צריך לתקן אם אצטרך להוסיף עוד מספר?" בגרסה ה"אפשרית", תצטרכו להוסיף עוד סניף אחד ולהוסיף מספר חדש ב-10 מקומות נוספים. ב"רצוי" מספיק להוסיף רק ענף אחד.
הגדר את המשימה לשחזר את האפשרות "הרצויה", ואז מצא דפוס בקוד, בצע החלפת משתנה וכתוב לולאה.
אם יש לך רעיון איך לפתור בעיה זו ללא לולאה בדרך אחרת, אנא כתוב בתגובות.

לולאות בתוך לולאות

בנושא זה אתה צריך לשים לב לדברים הבאים:
- מונים עבור הלולאות הפנימיות והחיצוניות חייבים להיות משתנים שונים.
- יש לאפס את המונה של הלולאה הפנימית פעמים רבות (כלומר, בגוף הלולאה החיצונית).
- במשימות פלט טקסט, אינך יכול לכתוב תחילה אות אחת בכמה שורות, ולאחר מכן את השנייה. תחילה עליך להדפיס את כל האותיות של השורה הראשונה, לאחר מכן את כל האותיות של השני, וכן הלאה.

עדיף להתחיל להסביר את הנושא של לולאות בתוך לולאות על ידי הסבר על החשיבות של איפוס המונה לאפס.
משימה לדוגמה:

המשתמש מזין שני מספרים: R ו-T. הדפס שתי שורות של תווים "#". השורה הראשונה צריכה להכיל תווים R. השורה השנייה מכילה חלקי T. אם מספר כלשהו הוא שלילי, הצג הודעת שגיאה.

R=5, T=11#####
###########

R=20, T=3#####################
# # #

R=-1, T=6ערך R חייב להיות לא שלילי

R=6, T=-2ערך T חייב להיות לא שלילי

ברור שגם לבעיה הזו יש לפחות שני פתרונות.
רצוי

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;
}

אפשרי מס' 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;
}

ההבדל הוא שבפתרון ה"אפשרי" נעשה שימוש במשתנה שני להוצאת השורה השנייה. אתה צריך להתעקש להשתמש באותו משתנה עבור שתי הלולאות. מגבלה זו יכולה להיות מוצדקת בעובדה שפתרון עם מונה אחד לשני מחזורים יהווה המחשה למונח "איפוס מונה". הבנת מונח זה הכרחי בעת פתרון הבעיות הבאות. כפשרה, אתה יכול לשמור את שני הפתרונות לבעיה.

בעיה טיפוסית בשימוש במשתנה מונה אחד עבור שתי לולאות מופיעה כך:
R=5, T=11#####
######

מספר התווים בשורה השנייה אינו תואם את הערך של T. אם אתה זקוק לעזרה בבעיה זו, עליך לבדוק את ההערות לגבי בעיות אופייניות עם לולאות. זה סימפטום מס' 3. זה מאובחן אם אתה מוסיף פלט ערך נגד מיד לפני המחזור השני. תוקן על ידי איפוס. אבל עדיף לא לספר את זה מיד. על התלמיד לנסות לנסח השערה אחת לפחות.

יש, כמובן, פתרון אחר. אבל מעולם לא ראיתי את זה בקרב סטודנטים. בשלב לימוד המחזורים, הסיפור על כך יסיח את תשומת הלב. אתה יכול לחזור אליו מאוחר יותר כשתלמד על פונקציות מחרוזת.
אפשרי מס' 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));

המשימה הנדרשת הבאה:

הצג את המספרים מ-0 עד 9. כל מספר צריך להיות על שורה משלו. מספר הספרות בשורה (W) מוזן מהמקלדת.

W = 10
1
2
3
4
5
6
7
8
9

W = 100000000000
1111111111
2222222222
3333333333
4444444444
5555555555
6666666666
7777777777
8888888888
9999999999

אם תלמיד שולט בטכניקה של החלפת משתנה, אז הוא יתמודד די מהר. בעיה אפשרית תהיה שוב באיפוס המשתנה. אם אתה לא יכול להתמודד עם השינוי, זה אומר שאתה מיהר וצריך לפתור בעיות פשוטות יותר.

תודה לך על תשומת הלב. עשו לייק והירשמו לערוץ.

נ.ב. אם אתה מוצא שגיאות הקלדה או שגיאות בטקסט, אנא הודע לי. ניתן לעשות זאת על ידי בחירת חלק מהטקסט ולחיצה על "⌘ + Enter" ב-Mac, ו-"Ctrl / Enter" במקלדות קלאסיות, או באמצעות הודעות פרטיות. אם אפשרויות אלו אינן זמינות, כתוב על שגיאות בהערות. תודה!

רק משתמשים רשומים יכולים להשתתף בסקר. להתחברבבקשה.

סקר לקוראים ללא קארמה

• 20,0%אני מלמד בצורה מקצועית, +12

• 10,0%אני מלמד באופן מקצועי, -11

• 70,0%אני לא מלמד, +17

• 0,0%אני לא מלמד, -10

• 0,0%אחר0

10 משתמשים הצביעו. 5 משתמשים נמנעו.

מקור: www.habr.com