מבחן להב
בחרו רמת קושי וסט תרגול
📖מבחן להב — סקירה כללית
מבחן להב הוא אחד המרכיבים המרכזיים ביום מיון התקשוב. המבחן בודק יכולת ניתוח קוד — קריאה שיטתית של תוכנית מחשב והבנת מה היא עושה.
מבנה המבחן
- משך: כ-40 דקות
- מבנה: 5 קטעי קוד + תרשים זרימה, כל אחד עם מספר שאלות
- שפה: קוד בסגנון Java (פסאודו-קוד מובנה)
מה נבדק?
המבחן בודק את היכולת שלכם ל:
- לעקוב אחרי ערכי משתנים לאורך ריצת התוכנית
- להבין לולאות
forו-while— מתי מתחילות, מתי נעצרות - להבין תנאים
if/else— איזה ענף מתבצע - לעקוב אחרי קריאות לפונקציות וערכי החזרה
- לקרוא תרשימי זרימה ולהבין את התהליך שהם מתארים
גישה מומלצת
- קראו את כל המדריך לפני שמתחילים לתרגל
- תרגלו ברמה קלה עד שאתם מרגישים בטוחים
- עלו לרמה בינונית — כאן מתחיל האתגר האמיתי
- נסו רמה קשה — גם אם לא מצליחים הכול, זה מרחיב את החשיבה
רשימת בדיקה לפני מבחן
- ✅ קראתי את כל המדריך
- ✅ פתרתי לפחות 5 שאלות ברמה קלה בהצלחה
- ✅ פתרתי לפחות 5 שאלות ברמה בינונית
- ✅ ניסיתי שאלות ברמה קשה
- ✅ אני יודע מהן הטעויות הנפוצות שלי
📋מושגי יסוד בקוד
משתנים (Variables)
משתנה הוא "קופסה" שמכילה ערך. לכל משתנה יש שם וסוג:
int x = 5; // משתנה מספרי שלם, ערך התחלתי 5 String s = "hello"; // משתנה מחרוזת, ערך התחלתי "hello"
ניתן לשנות את ערך המשתנה:
x = x + 3; // x היה 5, עכשיו 8 x = x * 2; // x היה 8, עכשיו 16
אופרטורים חשבוניים
| אופרטור | משמעות | דוגמה | תוצאה |
|---|---|---|---|
+ | חיבור | 7 + 3 | 10 |
- | חיסור | 7 - 3 | 4 |
* | כפל | 7 * 3 | 21 |
/ | חילוק שלם | 7 / 3 | 2 (לא 2.33!) |
% | שארית (מודולו) | 7 % 3 | 1 |
int ב-int, התוצאה היא int — החלק העשרוני נעלם. 7 / 2 = 3, לא 3.5!אופרטורי השוואה
| אופרטור | משמעות | דוגמה | תוצאה |
|---|---|---|---|
== | שווה ל- | 5 == 5 | true |
!= | שונה מ- | 5 != 3 | true |
> | גדול מ- | 5 > 3 | true |
< | קטן מ- | 5 < 3 | false |
>= | גדול או שווה | 5 >= 5 | true |
<= | קטן או שווה | 3 <= 5 | true |
תנאים — if / else
תנאי מאפשר לבצע קוד רק כשתנאי מסוים מתקיים:
if (x > 10) {
System.out.println("גדול");
} else if (x > 5) {
System.out.println("בינוני");
} else {
System.out.println("קטן");
}
אם x = 7: התנאי הראשון (7 > 10) שגוי, התנאי השני (7 > 5) נכון → ידפיס "בינוני".
לולאת for
לולאה שרצה מספר ידוע של פעמים:
for (int i = 0; i < 5; i++) {
System.out.println(i);
}
המבנה: for (ערך_התחלתי; תנאי_המשך; עדכון)
הלולאה הזו מדפיסה: 0, 1, 2, 3, 4 (לא 5! כי התנאי הוא i < 5).
לולאת while
לולאה שרצה כל עוד תנאי מתקיים:
int n = 100;
while (n > 1) {
n = n / 2;
}
מעקב: n=100 → 50 → 25 → 12 → 6 → 3 → 1. כשמגיע ל-1, התנאי 1 > 1 שגוי, הלולאה נעצרת.
מערכים (Arrays)
מערך הוא רשימה ממוספרת של ערכים. האינדקס מתחיל מ-0!
int[] arr = {10, 20, 30, 40, 50};
// arr[0] = 10, arr[1] = 20, ..., arr[4] = 50
// arr.length = 5
מעבר על כל איברי המערך:
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
פונקציות (Methods)
פונקציה היא קטע קוד עם שם שמקבל קלט ומחזיר פלט:
int square(int n) {
return n * n;
}
int result = square(5); // result = 25
כשקוראים לפונקציה: (1) הפרמטר מקבל את הערך שנשלח, (2) הקוד בגוף הפונקציה רץ, (3) return מחזיר ערך לקוד הקורא.
System.out.println
פקודת הדפסה — מדפיסה ערך למסך וגולשת לשורה חדשה:
System.out.println("Hello"); // מדפיס: Hello
System.out.println(5 + 3); // מדפיס: 8
System.out.print("A"); // מדפיס בלי ירידת שורה
System.out.print("B"); // מדפיס ליד: AB
פעולות על מחרוזות (String)
| פעולה | תיאור | דוגמה | תוצאה |
|---|---|---|---|
s.length() | אורך המחרוזת | "hello".length() | 5 |
s.charAt(i) | התו במיקום i | "hello".charAt(1) | 'e' |
s.substring(a, b) | תת-מחרוזת ממיקום a עד b (לא כולל) | "hello".substring(1, 4) | "ell" |
s1 + s2 | שרשור מחרוזות | "he" + "llo" | "hello" |
"hello".charAt(0) מחזיר 'h'.תרגול נוסף ואסטרטגיות
1. פתרו 5-10 שאלות ברצף
2. סמנו זמן — כמה לקח לכל שאלה?
3. בדקו תשובות
4. לכל טעות: מה סוג הטעות? (חישוב? קריאה? שיטה?)
5. חזרו על שאלות שטעיתם
מלכודות נפוצות
| מלכודת | איך להימנע |
|---|---|
| קריאה חפוזה | קראו פעמיים. תמיד |
| חישוב בראש | כתבו כל שלב |
| דילוג על בדיקה | בדקו סבירות לפני שממשיכים |
| ניחוש ללא אלימינציה | פסלו קודם, נחשו אחר כך |
💡טיפים למבחן להב
1. עקבו שורה אחרי שורה
אל תנסו "להבין" את הקוד במבט — עקבו אחרי כל שורה בזו אחר זו, כמו שמחשב עושה. כתבו את ערכי המשתנים בצד.
2. בנו טבלת מעקב
לכל לולאה, צרו טבלה עם עמודות למשתנים ושורה לכל סיבוב:
| סיבוב | i | sum | הערה |
|---|---|---|---|
| 1 | 0 | 0 | תחילת הלולאה |
| 2 | 1 | 1 | sum = 0 + 1 |
| 3 | 2 | 3 | sum = 1 + 2 |
3. היזהרו מחילוק שלם
זו הטעות הנפוצה ביותר! 7 / 2 = 3 (לא 3.5). כשרואים חילוק של int — החלק העשרוני נעלם.
4. שימו לב לגבולות הלולאה
for (i = 0; i < 5; ...) רץ 5 פעמים (0,1,2,3,4). for (i = 0; i <= 5; ...) רץ 6 פעמים (0,1,2,3,4,5). ההבדל הקטן הזה שווה הכול.
5. פונקציות — עצרו ועקבו
כשמגיעים לקריאה לפונקציה — עצרו, עברו לפונקציה, עקבו אחריה עם הערכים שנשלחו, רשמו את ה-return, וחזרו.
= (השמה) ל-== (השוואה). x = 5 שם את 5 ב-x. x == 5 בודק אם x שווה ל-5.סיכום — 5 הטיפים המרכזיים
- קראו הוראות פעמיים — 50% מהטעויות נובעות מקריאה חפוזה
- כתבו כל שלב — אל תסמכו על הזיכרון תחת לחץ
- בנו טבלת מעקב — לכל שאלה עם מספר שלבים
- בדקו סבירות — האם התשובה הגיונית?
- נהלו זמן — 2 דקות מקסימום. אם נתקעתם — סמנו ועברו
תוכנית תרגול של 7 ימים
| יום | פעילות | זמן |
|---|---|---|
| 1 | קריאת המדריך המלא + תרגול בסיסי | 30 דקות |
| 2 | תרגול רמה קלה — 10 שאלות | 20 דקות |
| 3 | ניתוח טעויות + תרגול נוסף רמה קלה | 25 דקות |
| 4 | תרגול רמה בינונית — 8 שאלות | 30 דקות |
| 5 | ניתוח טעויות + תרגול נוסף רמה בינונית | 30 דקות |
| 6 | תרגול רמה קשה — 5 שאלות | 30 דקות |
| 7 | סימולציה מלאה בתנאי זמן + ניתוח | 45 דקות |
