באיזה תת־נושא נתרגל?

לוחצים על תת־נושא כדי להתחיל לתרגל. ליד כל תת־נושא: מספר הרמות בו. לכל נושא יש סיכומון תחביר, ולרוב הנושאים גם סרטון הסבר. התרגול כרגע ב־C#; מחליפים שפה במתג שבכותרת, וההתקדמות בכל שפה נשמרת בנפרד.

1. נושא 1: פלט ▶ סרטון ההסבר
2. 01 פלט 11 רמות לתרגול ‹
   פירוט ▾

   מה מתרגלים ב־פלט C# · 110 שאלות · 11 רמות

   • Console.Write
   • Console.WriteLine
   • מחרוזות בין גרשיים
   • הערות //
   • הדפסת תרגילים חשבוניים (חיבור, חיסור, כפל)
   • סדר פעולות חשבון וסוגריים
   • חיבור רכיבי הדפסה באמצעות +
3. נושא 2: משתנים ▶ סרטון ההסבר
4. 02.1 משתנים 13 רמות לתרגול ‹
   פירוט ▾

   מה מתרגלים ב־משתנים C# · 130 שאלות · 13 רמות

   • חמשת סוגי המשתנים (int, double, bool, string, char)
   • הצהרה על משתנה
   • השמת ערך למשתנה
   • הצהרה והשמה באותה שורה
   • הדפסת הערך שבתוך משתנה
   • פעולות חשבון בין משתנים
   • שינוי ערכו של משתנה
   • חיבור משתנים ומחרוזות באמצעות +
   • המרה בין סוגים באמצעות parse
5. 02.2 משתנים — המרות משתנים 11 רמות לתרגול ‹
   פירוט ▾

   מה מתרגלים ב־משתנים — המרות משתנים C# · 110 שאלות · 11 רמות

   • המרה מפורשת באמצעות (int), (double) ו‑(char)
   • המרה משתמעת מ‑int ל‑double ומ‑char ל‑int
   • חיתוך החלק השברי בהמרה ל‑int
   • קוד ה‑Unicode של תו
   • סוג התוצאה בביטוי מעורב
   • ההבדל בין המרה של איבר לבין המרה של תוצאה
   • Parse מול המרה
6. נושא 3: קלט ▶ סרטון ההסבר
7. 03 קלט 20 רמות לתרגול ‹
   פירוט ▾

   מה מתרגלים ב־קלט C# · 200 שאלות · 20 רמות

   • Console.ReadLine()
   • קליטת מחרוזת מהמקלדת
   • עצירת התוכנית עד ללחיצת Enter
   • הדפסת הודעה למשתמש לפני הקליטה
   • שמירת הקלט במשתנה
   • קליטת מספר שלם באמצעות int.Parse(Console.ReadLine())
   • קליטת מספר ממשי באמצעות double.Parse(Console.ReadLine())
   • סדר הקליטות ושיוך הערכים למשתנים
   • תוכניות קלט‑חישוב‑פלט
8. נושא 4: חילוק ושארית (מודולו) ▶ סרטון ההסבר
9. 04 חילוק ושארית (מודולו) 17 רמות לתרגול ‹
   פירוט ▾

   מה מתרגלים ב־חילוק ושארית (מודולו) C# · 170 שאלות · 17 רמות

   • חילוק שלמים /
   • שארית החלוקה %
   • חילוק ומודולו בחזקות של 10 להסרה ולחילוץ של ספרות
   • שימוש חוזר בחילוק ובמודולו על אותו מספר
   • בדיקת התחלקות לפי שארית 0
   • ההבדל בין חילוק שלמים לחילוק מדויק
10. נושא 5: תנאי if ▶ סרטון ההסבר
11. 05.1 תנאי if — תנאי פשוט 16 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־תנאי if — תנאי פשוט C# · 160 שאלות · 16 רמות

    • פקודת if ותנאי בתוך סוגריים
    • בלוק בסוגריים מסולסלים
    • פקודת else
    • בלוק של כמה שורות בתוך תנאי
    • המשך הקוד אחרי סיום התנאי
    • אופרטורי ההשוואה > >= < <= == !=
    • ההבדל בין = לבין ==
    • תנאי על תוצאה של חישוב ושל שארית
    • תנאי על קלט מהמשתמש
    • שינוי ערך של משתנה בתוך תנאי
    • כמה תנאים פשוטים בזה אחר זה
12. 05.2 תנאי if — תנאי מורכב 16 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־תנאי if — תנאי מורכב C# · 160 שאלות · 16 רמות

    • תנאי "או" באמצעות ||
    • תנאי "וגם" באמצעות &&
    • מתי תנאי מורכב נכון ומתי לא
    • צמצום תנאי מורכב ל‑true או ל‑false שלב אחר שלב
    • סוגריים בתוך תנאי מורכב וסדר החישוב
    • בדיקת טווח באמצעות &&
    • בדיקה של כמה אפשרויות באמצעות ||
    • תנאי מורכב שמשלב חישוב ושארית
    • תנאי מורכב על קלט מהמשתמש
13. 05.3 תנאי if — תנאי מקונן 16 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־תנאי if — תנאי מקונן C# · 160 שאלות · 16 רמות

    • תנאי מקונן, כלומר if בתוך הבלוק של if אחר
    • if בתוך else
    • תנאי פנימי שאין לו else
    • מתי תנאי פנימי אינו נבדק כלל
    • הכלל ש‑else שייך ל‑if שהבלוק שלו נסגר ממש לפניו
    • שלוש אפשרויות ויותר באמצעות קינון
    • מה כבר ידוע בתוך else ואין צורך לבדוק שוב
    • שילוב של תנאי מקונן עם תנאי פשוט ועם תנאי מורכב
14. נושא 6: מחלקת Math ▶ סרטון ההסבר
15. 06.1 מחלקת Math — פעולות מתמטיות 14 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־מחלקת Math — פעולות מתמטיות C# · 140 שאלות · 14 רמות

    • המחלקה המתמטית Math כאוסף של קיצורי דרך לחישובים
    • Math.Abs
    • Math.Pow
    • Math.Sqrt
    • Math.Min
    • Math.Max
    • Math.Round
    • Math.Floor
    • פעולה על משתנה ועל תוצאה של חישוב
    • הדפסה ישירה של התוצאה ושמירתה במשתנה
    • קינון של פעולות Math זו בתוך זו
    • ההבדל בין עיגול למספר הקרוב לבין עיגול כלפי מטה
    • שילוב של הפעולות עם קלט, עם חילוק ועם תנאים
16. 06.2 מחלקת Math — מספר אקראי 9 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־מחלקת Math — מספר אקראי C# · 90 שאלות · 9 רמות

    • יצירת מגריל המספרים בשורה Random randomNum = new Random();
    • הגרלת מספר בטווח באמצעות randomNum.Next(a, b) כשהמספר השני אינו כלול
    • הגרלה באמצעות randomNum.Next(n) שנותנת מספר מ‑0 עד n - 1
    • אילו ערכים אפשריים בהגרלה ואילו לא
    • סיכוי כספירת תוצאות מתוך הטווח
    • שמירת המספר שהוגרל במשתנה
    • כמה הגרלות באותה תוכנית
    • פעולות חשבון על מספר שהוגרל
    • תנאים על מספר שהוגרל
17. נושא 7: לולאת for ▶ סרטון ההסבר
18. 07.1 לולאת for — for פשוט 20 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־לולאת for — for פשוט C# · 200 שאלות · 20 רמות

    • פקודת for ושלושת חלקי הכותרת שלה (אתחול, תנאי, קידום)
    • גוף הלולאה בסוגריים מסולסלים
    • מספר החזרות של הלולאה
    • קוד שממשיך אחרי סיום הלולאה
    • גבול שנקלט מהמשתמש
    • קלט ו‑if בתוך הלולאה
    • שימוש במשתנה i בגוף הלולאה
    • התחלה ממספר שאינו 0
    • <= לעומת <
    • קידום בקפיצות וספירה לאחור
    • לולאה שגופה אינו מתבצע כלל
19. 07.2 לולאת for — for מונה 15 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־לולאת for — for מונה C# · 150 שאלות · 15 רמות

    • משתנה מונה שמאותחל ל‑0 לפני הלולאה
    • הגדלת המונה ב‑1 בתוך if
    • הדפסת המונה אחרי סיום הלולאה
    • ספירה של קלטים שמקיימים תנאי
    • ספירה של ערכי i שמקיימים תנאי
    • count++ כקיצור של count = count + 1
    • שני מונים באותה לולאה
    • מונה שמאותחל במקום הלא נכון
    • שילוב מונה עם תנאי מורכב ועם שארית
20. 07.3 לולאת for — for סוכם/צובר 15 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־לולאת for — for סוכם/צובר C# · 150 שאלות · 15 רמות

    • משתנה סוכם שמאותחל ל‑0 לפני הלולאה
    • הוספת ערך לסוכם בכל סבב
    • הדפסת הסכום אחרי סיום הלולאה
    • סכום של קלטים וסכום של ערכי i
    • סכום חלקי שמודפס בכל סבב
    • סכום רק של ערכים שמקיימים תנאי
    • חישוב ממוצע מסכום ומכמות
    • חילוק שלמים בממוצע ו‑double
    • sum += x כקיצור של sum = sum + x
    • משתנה צובר במכפלה
    • שילוב סוכם עם מונה
21. 07.4 לולאת for — for עם מינימום ומקסימום 17 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־לולאת for — for עם מינימום ומקסימום C# · 170 שאלות · 17 רמות

    • משתנה שמחזיק את הערך הגדול ביותר שנקלט עד עכשיו
    • if שמעדכן אותו כשנקלט ערך גדול יותר
    • ערך התחלה למקסימום ולמינימום לפי תחום הערכים
    • מינימום ומקסימום באותה לולאה
    • מעקב אחרי המשתנה סבב אחר סבב
    • > לעומת >= כשיש ערכים שווים
    • ערך התחלה שגוי ומספרים שליליים
    • אתחול לפי הערך הראשון שנקלט
    • שמירת מספר הסבב שבו נמצא המקסימום
    • שילוב מינימום ומקסימום עם מונה ועם סוכם
22. נושא 8: לולאת while ▶ סרטון ההסבר
23. 08.1 לולאת while — while עם זקיף 19 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־לולאת while — while עם זקיף C# · 190 שאלות · 19 רמות

    • לולאת while ומשמעות "כל עוד"
    • בדיקת התנאי לפני כל סיבוב
    • זקיף כערך מיוחד שמסמן את סוף הקלט
    • קלט ראשון לפני הלולאה וקלט חוזר בסוף גוף הלולאה
    • הזקיף עצמו אינו מעובד
    • זקיף שנקלט מיד בהתחלה
    • ערכים שליליים שאינם הזקיף
    • לולאה שאינה מסתיימת כשהקלט החוזר חסר
    • סכימה, ספירה, מקסימום ומעקב אחרי הערך הקודם בתוך לולאת זקיף
    • בחירת זקיף שאינו מתנגש עם קלט חוקי
24. 08.2 לולאת while — while עם מעבר חוסם 15 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־לולאת while — while עם מעבר חוסם C# · 150 שאלות · 15 רמות

    • לולאת while שבתנאי שלה גבול
    • ערך שמשתנה בכל סיבוב ומתקרב לגבול
    • סיום הלולאה כשהגבול נחצה
    • הערך של המשתנה אחרי הלולאה
    • מספר הסיבובים
    • ההבדל בין < ל‑<= בגבול
    • בדיקה לפני הוספה כדי לא לחצות את הגבול
    • גבול שנקלט מהמשתמש
    • התקרבות לגבול בקלט ובלי קלט
    • לולאה שאינה מסתיימת כשהערך מדלג על הגבול
    • המרה של for ל‑while
25. 08.3 לולאת while — while עם דגל 15 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־לולאת while — while עם דגל C# · 150 שאלות · 15 רמות

    • משתנה bool כדגל
    • אתחול הדגל לפני הלולאה
    • דגל בתנאי while בצורה flag == false או flag == true
    • הרמת הדגל בתוך הלולאה בעקבות תנאי
    • סיום הלולאה בבדיקה הבאה של התנאי ולא מיד
    • דגל שאינו מורם ולולאה שאינה מסתיימת
    • דגל בשילוב תנאים נוספים באמצעות && ו‑||
    • בדיקת הדגל אחרי הלולאה
    • דגל שנדרס בתוך הלולאה
    • דגל בשילוב זקיף ומונה
26. 08.4 לולאת while — while מסננת קלט 12 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־לולאת while — while מסננת קלט C# · 120 שאלות · 12 רמות

    • לולאת while שחוזרת על קלט עד שהוא תקין
    • תנאי שמתאר קלט לא תקין ולא קלט תקין
    • קלט ראשון לפני הלולאה וקלט חוזר בתוך הלולאה
    • הודעת שגיאה בכל ניסיון שגוי
    • קלט תקין מהניסיון הראשון שאינו נכנס ללולאה
    • תנאי סינון עם || לטווח
    • תנאי סינון עם שארית
    • ספירת ניסיונות
    • מסננת שאחריה שימוש בערך
    • מסננת ואחריה לולאת זקיף
    • סדר השורות בתוך המסננת
27. נושא 9: לולאות מקוננות ▶ סרטון ההסבר
28. 09 לולאות מקוננות 20 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־לולאות מקוננות C# · 200 שאלות · 20 רמות

    • לולאה בתוך לולאה
    • לולאה חיצונית שקובעת את מספר השורות ולולאה פנימית שקובעת את תוכן השורה
    • שני מונים בשמות שונים
    • Console.Write בתוך הלולאה הפנימית ו‑Console.WriteLine() אחריה
    • ציור מלבנים ומשולשים של תווים
    • גבול פנימי שתלוי במונה החיצוני
    • שימוש בשני המונים יחד בתוך הלולאה הפנימית
    • if בתוך לולאה מקוננת
    • for בתוך for בתוך while
    • קלט בתוך לולאה מקוננת
    • איפוס משתנים בין סיבובים של הלולאה החיצונית
    • שלוש רמות של קינון
29. נושא 10: מחרוזות ▶ סרטון ההסבר
30. 10.1 מחרוזות — אורך ושליפת תו ממיקום 15 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־מחרוזות — אורך ושליפת תו ממיקום C# · 150 שאלות · 15 רמות

    • Length לקבלת אורך המחרוזת
    • שליפת תו ממיקום באמצעות []
    • מיקומים שמתחילים ב‑0
    • המיקום האחרון Length - 1
    • רווח כתו שנספר ותופס מיקום
    • מעבר על כל תווי המחרוזת בלולאה
    • השוואת תו לתו
    • ספירת תווים
    • מעבר מהסוף להתחלה
    • מיקום שמחושב מהאורך
    • שני מיקומים שנבדקים יחד
    • מעבר על שתי מחרוזות בלולאות מקוננות
31. 10.2 מחרוזות — פעולות קיצור דרך 15 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־מחרוזות — פעולות קיצור דרך C# · 150 שאלות · 15 רמות

    • Contains לבדיקה האם טקסט מופיע במחרוזת
    • Substring לחיתוך קטע לפי מיקום התחלה ואורך
    • IndexOf למיקום המופע הראשון של תו או של טקסט
    • IndexOf עם מיקום שממנו מתחיל החיפוש
    • LastIndexOf לחיפוש מהסוף
    • הבחנה בין אותיות גדולות לקטנות
    • השוואת מחרוזות באמצעות ==
    • שילוב של כמה פעולות בביטוי אחד
    • שילוב הפעולות עם Length, עם [] ועם לולאות
32. נושא 11: פעולות (סטטיות/חיצוניות) ▶ סרטון ההסבר
33. 11.1 פעולות — מבוא ופעולה שלא מקבלת ערך ולא מחזירה ערך 25 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־פעולות — מבוא ופעולה שלא מקבלת ערך ולא מחזירה ערך C# · 250 שאלות · 25 רמות

    • למה צריך פעולות חיצוניות
    • מיקום הפעולה מחוץ ל‑Main
    • כותרת הפעולה static void ושם
    • גוף הפעולה בסוגריים מסולסלים
    • קריאה לפעולה בשמה עם סוגריים ונקודה‑פסיק
    • ה‑Main כנקודת ההתחלה של התוכנית
    • קריאה חוזרת לאותה פעולה
    • קוד שממשיך אחרי הקריאה
    • קריאה לפעולה מתוך לולאה
    • קלט ותנאים ולולאות בתוך הפעולה
    • ההבדל בין "כתבו תוכנית" ל"כתבו פעולה"
    • משתנים שנוצרים בתוך פעולה ואינם נגישים מחוץ לה
34. 11.2 פעולות — פעולה שמקבלת ערך ולא מחזירה ערך 14 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־פעולות — פעולה שמקבלת ערך ולא מחזירה ערך C# · 140 שאלות · 14 רמות

    • פרמטרים בכותרת הפעולה עם טיפוס ושם
    • שליחת ערכים בקריאה לפעולה
    • התאמה לפי סדר בין הערכים שנשלחו לפרמטרים
    • פרמטרים מכמה טיפוסים
    • שליחת משתנים וביטויים חשבוניים
    • קריאה לפעולה מתוך לולאה עם ערך משתנה
    • ההבדל בין "מקבלת" ל"קולטת"
    • הפרמטר כמשתנה נפרד מהמשתנה שנשלח מה‑Main
35. 11.3 פעולות — פעולה שלא מקבלת ערך ומחזירה ערך 13 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־פעולות — פעולה שלא מקבלת ערך ומחזירה ערך C# · 130 שאלות · 13 רמות

    • טיפוס הערך המוחזר בכותרת במקום void
    • הפקודה return
    • הקריאה לפעולה הופכת לערך שהוחזר
    • שמירת הערך המוחזר במשתנה או הדפסתו ישירות
    • שימוש בערך המוחזר בתוך ביטוי
    • פעולה שקולטת קלט ומחזירה תוצאה
    • קריאה שהערך שלה לא נשמר
    • return בתוך תנאי ובתוך לולאה שמסיים את הפעולה מיד
    • פעולה שמחזירה bool
    • ההבדל בין "מחזירה" ל"מדפיסה"
36. 11.4 פעולות — פעולה שמקבלת ערך ומחזירה ערך 20 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־פעולות — פעולה שמקבלת ערך ומחזירה ערך C# · 200 שאלות · 20 רמות

    • כותרת עם טיפוס מוחזר ופרמטרים
    • החזרת תוצאה שמחושבת מהפרמטרים
    • שימוש בערך המוחזר בתוך ביטוי ובתוך תנאי
    • קריאה לפעולה בתוך קריאה אחרת
    • פעולה שמחזירה bool כתשובה לשאלת "האם"
    • לולאה בתוך פעולה מחזירה
    • return בתוך לולאה שמסיים את הפעולה מיד
    • הפרמטר כעותק של הערך שנשלח
    • פעולה שקוראת לפעולה אחרת
    • מבנה של פעולה ותוכנית ראשית שמשתמשת בה
37. נושא 12: מערכים ▶ סרטון ההסבר (ללא מערך דו-ממדי)
38. 12.1 מערכים — שימוש במערכים 25 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־מערכים — שימוש במערכים C# · 250 שאלות · 25 רמות

    • יצירת מערך ב‑new
    • מיקום במערך שמתחיל ב‑0
    • השמה וקריאה של תא לפי מיקום
    • אתחול מערך ברשימת ערכים בסוגריים מסולסלים
    • Length
    • מעבר על מערך בלולאה
    • מילוי מערך מקלט ומערך בגודל שנקלט מהמשתמש
    • מונה, סוכם, מינימום ומקסימום על מערך
    • פעולה שמקבלת מערך ומחזירה ערך
    • השוואת תאים סמוכים
    • מיקום של ערך במערך
    • מערך מונים
39. 12.2 מערכים — העתקת מערכים 10 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־מערכים — העתקת מערכים C# · 100 שאלות · 10 רמות

    • שם של מערך כמצביע על המערך
    • arr2 = arr שיוצר מצביע נוסף לאותו מערך ולא מערך חדש
    • שינוי דרך שם אחד שנראה דרך השם השני
    • מערך שנשלח לפעולה ומשתנה בתוכה
    • העתקה אמיתית באמצעות new ולולאה תא‑תא
    • העתקה בסדר הפוך
    • מערך חדש שנבנה מערכי מערך קיים
    • העתקה חלקית למערך בגודל מדויק
40. 12.3 מערכים — מערך דו-ממדי 20 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־מערכים — מערך דו-ממדי C# · 200 שאלות · 20 רמות

    • יצירת מערך דו-ממדי ב‑new int[rows, cols] ומספר השורות לפני מספר העמודות
    • פנייה לתא ב‑m[i, j] עם מיקומים שמתחילים ב‑0
    • השמה וקריאה של תא וערך התחלתי 0
    • רשימת אתחול בסוגריים מסולסלים מקוננים
    • GetLength(0) ו‑GetLength(1)
    • לולאה על שורה קבועה ועל עמודה קבועה
    • לולאות מקוננות למילוי ולהדפסה כטבלה
    • סדר הלולאות והדפסה לפי עמודות
    • קליטת מערך דו-ממדי שורה אחרי שורה וסכום של שורה
    • מונה על כל התאים
    • פעולה שמקבלת מערך דו-ממדי ונקראת בתוך לולאה
    • פעולת bool שמחפשת ערך
    • אלכסון ראשי ואלכסון משני במטריצה ריבועית
    • הערך הגדול ביותר עם מספר השורה ומספר העמודה שלו
    • השוואת תאים סמוכים בשורה
    • החלפה בין m[i, j] ל‑m[j, i]
    • סכומי עמודות עם מיקום הסכום הקטן ביותר
    • השוואת שורה למערך חד-ממדי
    • מערך ממוין שורה אחרי שורה כולל המעבר בין שורות
    • ספירת ערכים שמופיעים פעם אחת בלבד
41. נושא 13: עצמים 📄 סיכומון התחביר (אין סרטון לנושא הזה)
42. 13.1 עצמים — כתיבת מחלקה 20 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־עצמים — כתיבת מחלקה C# · 200 שאלות · 20 רמות

    • מחלקה ותכונות private
    • כותרת של פעולה בונה
    • this. לפני תכונה (חובה כשלפרמטר ולתכונה יש אותו שם)
    • יצירת עצם ב‑new
    • פעולת Get וקריאה לפעולה של עצם בעזרת נקודה
    • פעולה בונה שמאתחלת תכונה לערך קבוע
    • פעולות פנימיות שמשנות תכונה (ובהן Set)
    • פעולות פנימיות שמחזירות ערך מחושב
    • ToString והדפסת עצם
    • תכונה בוליאנית
    • ההבדל בין פרמטר לתכונה
    • פעולה שנעזרת בפעולה אחרת של אותו עצם
    • כתיבת פעולה בונה
    • כתיבת פעולה פנימית
    • כתיבת מחלקה שלמה
    • בדיקת תקינות בפעולה הבונה
    • פעולה פנימית עם פרמטרים ושני תנאים נפרדים
    • פעולה פנימית שחייבת להשתמש בפעולה קיימת של המחלקה ובודקת תכונה בוליאנית ותנאי מורכב
    • כתיבת מחלקה שלמה עם בדיקת תקינות ופעולה שנעזרת בפעולה בוליאנית של המחלקה
    • כתיבת מחלקה שלמה שבה פעולה נעזרת בפעולה שנעזרת בפעולה שלישית
43. 13.2 עצמים — שימוש במחלקה 15 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־עצמים — שימוש במחלקה C# · 150 שאלות · 15 רמות

    • יצירת כמה עצמים מאותה מחלקה ב‑new ולכל אחד ערכים משלו
    • שמירת ערך מוחזר במשתנה והדפסתו
    • תכונות private כפי שהן נראות מהתוכנית הראשית
    • קריאה מקוננת כמו a.SetX(a.GetX() + 5)
    • השוואה בין שני עצמים דרך פעולות Get
    • שגיאות אופייניות בתוכנית הראשית (פעולת void בתוך ביטוי, סדר ארגומנטים שגוי, קריאה לפעולה בלי עצם)
    • כתיבת שורות בתוכנית הראשית מול מחלקה נתונה
    • b = a שנותן שם נוסף לאותו עצם ולא עצם חדש
    • null כמשתנה שאינו מצביע על שום עצם
    • פעולה חיצונית שמקבלת עצם ומשנה אותו
    • פעולה חיצונית שמקבלת שני עצמים ומחזירה bool
    • פעולה חיצונית שמחזירה אחד מהעצמים שקיבלה
    • תוכנית ראשית מול מחלקה שנתונה במילים עם "הניחו שקיימות פעולות Get ו‑Set"
    • פעולה פנימית שמקבלת עצם אחר other מאותה מחלקה ומי this ומי other
    • פעולת other שבודקת שוויון של כל התכונות כולל תכונת char
    • פעולת other שמשווה סדר לפי שתי תכונות יחד עם פעולה חיצונית שחייבת להשתמש בה
44. 13.3 עצמים — מערך של עצמים 20 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־עצמים — מערך של עצמים C# · 200 שאלות · 20 רמות

    • יצירת מערך של עצמים ב‑new X[n] ותאים ריקים (null)
    • הכנסת עצם לתא ב‑new והפעלת פעולה על תא (arr[i].GetName())
    • לולאה על arr.Length והדפסת עצמים דרך ToString
    • הפעלת פעולת void על כל התאים
    • פעולה חיצונית שמקבלת מערך של עצמים ומחזירה סכום
    • ספירה לפי תנאי
    • הדפסה לפי פרמטר סף
    • תכונה בוליאנית מול פרמטר בוליאני
    • "האם קיים" ו"האם כולם" עם return בתוך הלולאה
    • הערך הקיצוני עם החזרת העצם עצמו (Hotel best = arr[0])
    • מינימום בעזרת פעולת other נתונה ומי this ומי other
    • פעולה שחייבת להשתמש בפעולה אחרת לכל עצם
    • פעולה שמחזירה מערך חדש
    • מערך סכומים לפי תכונה (הקוד כמיקום)
    • החזרה והדפסה באותה פעולה
    • מערך חדש בגודל שנקבע בספירה עם מיקום כתיבה נפרד
    • לולאה על טווח ערכים שקוראת לפעולה אחרת
    • מקסימום של סכום לכל ערך של תכונה
    • זוגות עם j != i
    • מערך חדש בלי כפילויות
45. 13.4 עצמים — הכלה 18 רמות לתרגול ‹
    פירוט ▾

    מה מתרגלים ב־עצמים — הכלה C# · 180 שאלות · 18 רמות

    • תכונה מטיפוס int[]
    • תכונה שהיא עצם ממחלקה אחרת ופעולה בונה שמקבלת עצם
    • פעולה בונה שמקבלת מערך ופעולות פנימיות שעוברות על המערך של העצם
    • new בתוך new
    • פעולת Get שמחזירה עצם ושרשור קריאות
    • מחלקה שמחזיקה מערך של עצמים ופעולות שמפעילות את הפעולות של העצמים שבמערך
    • ToString שכולל את העצם הפנימי
    • שני עצמים שחולקים עצם פנימי אחד
    • השוואה בין תאים סמוכים במערך של העצם
    • פעולה עם other שמשווה את העצמים הפנימיים של שני העצמים
    • פעולה שמשתמשת בפעולה של העצם הפנימי במקום לחשב בעצמה
    • החזרת עצם מתוך המערך בעזרת פעולה שמשווה בין שני עצמים
    • הפרשים עם Math.Abs ופרמטר בוליאני שקובע מה הפעולה מחשבת
    • פעולה שנעזרת בפעולה אחרת של אותו עצם
    • פעולה שמקבלת עצם ומחפשת במערך של העצם
    • לולאות מקוננות על המערכים של שני עצמים
    • פעולה חיצונית על מערך של עצמים שבתוכם עצמים אחרים