מבחן להב
הערכה המלאה החל מ-₪130 ל-7 ימים
האתר הוא פלטפורמת הכנה עצמאית ואינו קשור לצה"ל, ליחידה 8200 או לגוף רשמי כלשהו.
מבחן להב הוא אחד המבחנים ביום המיון לאשכול מקצועות המחשב בחיל התקשוב. צה"ל אינו מפרסם את מבנהו, את מספר השאלות בו או את סולם הציונים שלו, אבל כל המקורות שמתארים אותו מסכימים על דבר אחד: הוא נותן לכם קוד ומבקש שתגידו מה הוא עושה. זו המיומנות שהמאגר כאן מתרגל: 180 שאלות בשלוש רמות קושי, ומבחן מלא של 40 שאלות ברצף לסיום. המאגר כלול בערכת ממר"ם ומקצועות המחשב.
המאגר בנוי מסוג שאלה אחד, בכוונה: קטע קוד קצר וקביעה מה הוא ידפיס. הקוד כתוב בתחביר של שפת תכנות אמיתית, ולכן המאגר מניח נוחות בסיסית בקריאת קוד ואינו נקודת ההתחלה למי שמעולם לא ראה קוד. אם אין לכם רקע, אל תתחילו כאן. התחילו במבחן להב לדוגמה, שבו כל שאלה מגדירה בעצמה את הפקודות שבה ואפשר לפתור אותו בלי שום ידע מוקדם, ורק אחר כך חזרו לכאן.
לצד המאגר הזה כדאי לתרגל את השפה המומצאת, שמכסה את הצד השני של יום המיון, ולקרוא את מדריך השאלות והתשובות על מבחן להב כדי לדעת מה מפורסם רשמית ומה לא.
מבחן להב - סקירה כללית
מבחן להב הוא אחד המבחנים ביום המיון לאשכול מקצועות המחשב בחיל התקשוב. המכנה המשותף לכל התיאורים הפומביים שלו הוא אחד: המבחן נותן לכם קוד ומבקש שתגידו מה הוא עושה.
מה מפורסם רשמית, ומה לא
באתר ההתגייסות מפורסם שיום המיונים לאשכול מקצועות המחשב כולל מספר בחינות שאינן מחייבות ידע מוקדם, אך בודקות יכולות אלגוריתמיות ותכנותיות הנדרשות לתפקידי האשכול. שימו לב שזה משפט על יום המיון כולו, לא על מבחן להב לבדו, ושיש לו שני חצאים. רוב האתרים מצטטים רק את הראשון.
המחלוקת שכדאי להכיר
המקורות שמתארים את להב חלוקים בשאלה מרכזית אחת: האם הקוד כתוב בשפת תכנות אמיתית, או בסימון שהמבחן עצמו מלמד תוך כדי. דיווח מפורט של מועמדת בפורום מעמיד את להב מול מבחן השפה המומצאת ומתאר אותו כמבחן בשפה קיימת; לעומת זאת מכוני הכנה מתארים דף הוראות שמסביר איך הקוד עובד, ומשווים את להב למבחן מחשבון קרב. אין דרך להכריע בין השתיים, ולכן לא נציג אף אחת מהן כעובדה.
החדשות הטובות: ההכרעה הזאת כמעט לא משנה מה כדאי לכם לתרגל. בשני התרחישים המיומנות היא אותה מיומנות - לבצע הוראות נתונות בדיוק, ולעקוב אחרי ערכים שמשתנים בלי לאבד שלב.
כמה זמן יש
מכון הכנה ישראלי מציין שהמבחן אורך כ-40 דקות. מועמד שדיווח בפורום על החומר שנשלח למתמיינים כתב על 60 דקות. שני המספרים אינם רשמיים, והם מדיווחים שנפרדים בהם שנים, ולכן אל תבנו על אף אחד מהם. מה שכן שווה: לתרגל עם שעון כדי שהקצב יהפוך לתחושה פנימית.
מה בודקים בפועל
- לעקוב אחרי ערכי משתנים לאורך ריצת התוכנית
- להבין לולאות - מתי מתחילות, כמה סיבובים, מתי נעצרות
- להבין תנאים - איזה ענף מתבצע, ובמיוחד מה קורה בדיוק על הגבול
- לעקוב אחרי קריאות לפונקציות ולערכי ההחזרה שלהן
- להבחין בין מה שהודפס לבין מה שנשאר בסוף במשתנה
איך בנוי המאגר הזה, בכנות
מאתיים ועשרים שאלות: 180 שאלות תרגול בשלוש רמות קושי, שישה סטים של עשר שאלות בכל רמה, ועוד מבחן מלא אחד של 40 שאלות עם שעון. כולן מסוג אחד - קטע קוד קצר וקביעה מה הוא ידפיס - והקוד כתוב בתחביר של שפת תכנות אמיתית. המאגר כולו כלול בערכת תקשוב; המבחן לדוגמה שבקישור למטה נשאר פתוח לכולם. זה תרגול חזק לביצוע מדויק של הוראות ולסבלנות עם פרטים, שתי היכולות שנופלות ראשונות תחת לחץ. הוא כן מניח נוחות בסיסית בקריאת קוד.
גישה מומלצת
- קראו את כל המדריך לפני שמתחילים לתרגל
- תרגלו ברמה קלה עד שאתם מרגישים בטוחים
- עלו לרמה בינונית - כאן מתחיל האתגר האמיתי
- נסו רמה קשה - גם אם לא מצליחים הכול, זה מרחיב את החשיבה
- סיימו במבחן המלא - 40 שאלות ברצף, עם שעון, אחרי שכיסיתם את שלוש הרמות
רשימת בדיקה לפני מבחן
- קראתי את כל המדריך
- פתרתי לפחות 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. חזרו על שאלות שטעיתם
מלכודות נפוצות
| מלכודת | איך להימנע |
|---|---|
| קריאה חפוזה | קראו פעמיים. תמיד |
| חישוב בראש | כתבו כל שלב |
| דילוג על בדיקה | בדקו סבירות לפני שממשיכים |
| ניחוש ללא אלימינציה | פסלו קודם, נחשו אחר כך |
להב מול המבחנים השכנים ביום המיון
חלק גדול מהבלבול ברשת על "מבחן להב" נובע מכך שאנשים מערבבים בין המבחנים השונים של אותו יום מיון. הטבלה מסכמת את מה שמכוני הכנה ודיווחי מועמדים מתארים. היא אינה מסמך רשמי, וגם רשימת המבחנים עצמה שנויה במחלוקת בין המקורות - יש מי שמונה גם מבחן מיקום בינארי, ויש מי שמציין שמבחני הבנת תהליכים וחשיבה לוגית כבר אינם חלק מהמיון הזה.
| המבחן | מה מתארים שקורה בו | איפה מתרגלים אצלנו |
|---|---|---|
| להב | קוד נתון ושאלות עליו | הדף הזה, והמבחן לדוגמה |
| מחשבון קרב / שפות מומצאות | לומדים שפה מומצאת במקום ואז מיישמים אותה | שפה מומצאת |
| שליפת מידע ממאמרים | שני טקסטים, ושאלות שהתשובה להן מוסתרת בתוכם | אנגלית טכנית (מיומנות קרובה) |
| אנגלית | קטעי אנסין בהקשר טכנולוגי, ולעיתים גם סרטון | אנגלית טכנית |
איפה להב יושב בתוך תהליך המיון
הזימון ליום המיון של מקצועות המחשב מגיע אחרי שלבי המיון המוקדמים - מבחני דפ"ר בצו הראשון, ולאחריו יום המא"ה. מכוני הכנה מציינים ציון דפ"ר של 60 ומעלה כתנאי סף לזימון, ובחלק מהתפקידים 70 ומעלה. הנתונים האלה אינם מסמך רשמי והם מסוג הדברים שהצבא משנה בלי להודיע, אז התייחסו אליהם ככיוון ולא כהבטחה.
מה שכן שווה להפנים: להב הוא מרכיב אחד מתוך יום שלם, והוא משוקלל יחד עם כל השאר. איך בדיוק, ובאיזה משקל, אינו מפורסם. לכן השאלה השימושית אינה "מה ציון להב שאני צריך" אלא "כמה שאלות אני מספיק לפתור נכון" - וזה משתנה שנמצא בשליטתכם.
טיפים למבחן להב
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 הטיפים המרכזיים
- קראו הוראות פעמיים - קריאה חפוזה היא מקור נפוץ לטעויות
- כתבו כל שלב - אל תסמכו על הזיכרון תחת לחץ
- בנו טבלת מעקב - לכל שאלה עם מספר שלבים
- בדקו סבירות - האם התשובה הגיונית?
- נהלו זמן - 2 דקות מקסימום. אם נתקעתם - סמנו ועברו
תוכנית תרגול של 7 ימים
| יום | פעילות | זמן |
|---|---|---|
| 1 | קריאת המדריך המלא + תרגול בסיסי | 30 דקות |
| 2 | תרגול רמה קלה - 10 שאלות | 20 דקות |
| 3 | ניתוח טעויות + תרגול נוסף רמה קלה | 25 דקות |
| 4 | תרגול רמה בינונית - 8 שאלות | 30 דקות |
| 5 | ניתוח טעויות + תרגול נוסף רמה בינונית | 30 דקות |
| 6 | תרגול רמה קשה - 5 שאלות | 30 דקות |
| 7 | סימולציה מלאה בתנאי זמן + ניתוח | 45 דקות |
המבחן המלא - 40 שאלות ברצף
המבחן המלא מרכז 40 שאלות בסט אחד, מסודרות מהקל לקשה: כשליש ברמה הקלה, כשליש ברמה הבינונית והשאר ברמה הקשה. הוא נועד לאמן את הדבר היחיד שהסטים הקצרים לא מאמנים: לשמור על דיוק גם בשאלה ה-35, כשהריכוז כבר נשחק.
צה"ל אינו מפרסם את מספר השאלות במבחן להב האמיתי או את משך הזמן שלו, ואנחנו לא מנחשים. 40 שאלות הן בחירה שלנו לתרגול. אל תסיקו ממנה שום דבר על המבחן עצמו.
איך לגשת אליו
- קבעו זמן מראש והפעילו שעון. לתרגול אנחנו ממליצים על 60 דקות, כלומר דקה וחצי לשאלה בממוצע: פחות מזה ברמה הקלה, יותר ברמה הקשה.
- אל תחזרו אחורה באמצע. שאלה שנתקעתם בה, סמנו והמשיכו. חזרו אליה רק אם נשאר זמן בסוף.
- עבדו עם דף מעקב: טבלה קטנה לכל שאלה עם לולאה או רקורסיה. בשאלה ה-30 הזיכרון כבר לא מספיק.
- אחרי הסיום עברו על ההסבר של כל שאלה שטעיתם בה, ורשמו לעצמכם את סוג הטעות: גבול לולאה, חילוק שלם, ערך מודפס מול נשמר, רקורסיה שנעצרה מוקדם.
מה לעשות עם התוצאה
| נכונות מתוך 40 | מה זה אומר על התרגול | הצעד הבא |
|---|---|---|
| 36 ומעלה | המעקב יציב לאורך זמן | חזרו על המבחן אחרי שבוע עם פחות זמן, ותרגלו את השפה המומצאת |
| 28 עד 35 | הבסיס טוב, הדיוק נשחק בסוף | בדקו איפה נפלו הטעויות: אם רובן בשליש האחרון, הבעיה היא סיבולת ולא ידע |
| 20 עד 27 | יש פערים במבנה מסוים | מיינו את הטעויות לפי סוג, וחזרו לסטים של הרמה שבה הסוג הזה מופיע |
| מתחת ל-20 | מוקדם מדי למבחן מלא | חזרו לרמה הקלה והבינונית, ופתרו כל סט עד שהוא נקי מטעויות |
הטבלה מתארת את התרגול שלנו בלבד. אין לה שום קשר לסולם הציונים של המבחן האמיתי, שאינו מפורסם.
רמה קלה
רמה קלה - מבנה אחד בכל שאלה
ברמה הקלה כל שאלה בודקת מבנה אחד: משתנה שמשתנה כמה פעמים, תנאי יחיד, לולאה קצרה או פעולה אחת על מחרוזת. אין כאן טריקים. המטרה היא להפוך את המעקב אחרי הקוד להרגל: שורה, ערך, שורה, ערך, בלי לדלג ובלי לנחש.
מה מתאמנים כאן
- לקרוא כל שורה לפי הסדר, ולכתוב ליד כל משתנה את ערכו הנוכחי.
- לזהות את ההבדל בין
/(חילוק שלם) ל-%(שארית). - לספור סיבובי לולאה לפי התנאי בפועל:
i < 5הם חמישה סיבובים,i <= 5הם שישה. - להבחין בין מה שמודפס בתוך הלולאה לבין מה שמודפס אחריה.
דוגמה:
int x = 10; x = x - 4; x = x * 2; System.out.println(x % 5);
מעקב: x = 10, אחר כך 6, אחר כך 12. השארית של 12 בחלוקה ל-5 היא 2. הפלט: 2. מי שהדפיס 12 שכח את השורה האחרונה; מי שהדפיס 2.4 קרא את % כחילוק.
שתי הטעויות שחוזרות ברמה זו
| הטעות | איך היא נראית | התיקון |
|---|---|---|
| חילוק שלם | 7 / 2 נקרא כ-3.5 | שני int נותנים int: 3 |
| גבול הלולאה | סופרים סיבוב אחד יותר מדי או פחות מדי | כתבו את ערכי i בפועל: 0, 1, 2, 3, 4 |
הרמה הזו נועדה לבנות דיוק, לא מהירות. עברו לרמה הבינונית רק כשאתם פותרים סט שלם בלי טעות אחת. אם אתם טועים, ההסבר של כל שאלה מראה את המעקב המלא; השוו אותו למה שכתבתם ומצאו את השורה שבה נפרדתם ממנו.
רמה בינונית
רמה בינונית - שני מבנים שעובדים יחד
ברמה הבינונית כל שאלה משלבת שני מבנים: לולאה עם תנאי בתוכה, לולאה שבונה מחרוזת, פונקציה שנקראת מתוך לולאה, מערך שעוברים עליו, או שתי לולאות זו בתוך זו. המעקב מתארך ל-6 עד 15 צעדים, ולכן הדבר החשוב ביותר כאן הוא טבלת מעקב עם עמודה לכל משתנה.
מה מתאמנים כאן
- לנהל שניים או שלושה משתנים במקביל בלי לאבד אף אחד מהם.
- לעבוד עם מערכים: האינדקס הראשון הוא 0, והאחרון הוא
length - 1. - לבנות מחרוזת צעד אחרי צעד ולשים לב לסדר:
s = c + sמוסיף בהתחלה,s = s + cמוסיף בסוף. - לעצור בקריאה לפונקציה, לחשב את ערך ההחזרה, ולחזור לשורה שקראה לה.
דוגמה:
int[] arr = {4, 9, 2, 7};
int count = 0;
for (int i = 0; i < arr.length; i++) {
if (arr[i] % 2 == 1) {
count += arr[i];
}
}
System.out.println(count);
| i | arr[i] | אי-זוגי? | count |
|---|---|---|---|
| 0 | 4 | לא | 0 |
| 1 | 9 | כן | 9 |
| 2 | 2 | לא | 9 |
| 3 | 7 | כן | 16 |
הפלט: 16. שימו לב לשם המשתנה: הוא נקרא count אבל צובר סכום, לא כמות. הקוד עושה מה שכתוב בו, לא מה שהשם מרמז.
המלכודות של הרמה הזו
- מודפס מול נשמר: אם ההדפסה בתוך הלולאה, יש כמה שורות פלט; אם היא אחריה, יש שורה אחת עם הערך הסופי.
- לולאות מקוננות: הלולאה הפנימית רצה עד הסוף בכל סיבוב של החיצונית. ספרו כמה פעמים בסך הכול מתבצעת השורה הפנימית.
- ערך החזרה שלא נשמר: קריאה לפונקציה בלי השמה (
f(x);לבד) לא משנה שום משתנה בחוץ.
ברמה זו כדאי להתחיל לעבוד עם שעון: שתי דקות לשאלה. אם שאלה לוקחת יותר, סמנו והמשיכו, וחזרו אליה בסוף הסט.
רמה קשה
רמה קשה - רקורסיה, מערכים דו-ממדיים ותרחישים
ברמה הקשה הקוד ארוך יותר ומתנהג כמו אלגוריתם קטן: פונקציה שקוראת לעצמה, מערך דו-ממדי, מכונת מצבים שעוברת על מחרוזת, או פונקציה שנקראת כמה פעמים עם קלטים שונים. חלק מהשאלות מנוסחות כתרחיש (מערכת שמייצרת קוד למשתמש), אבל מתחת לניסוח זו אותה משימה: להריץ את הקוד בראש, בדיוק.
מה מתאמנים כאן
- רקורסיה: לרשום כל קריאה כשורה משלה, לרדת עד תנאי העצירה, ואז לחזור למעלה ולחשב את ערכי ההחזרה מהסוף להתחלה.
- מערכים דו-ממדיים:
grid[r][c]הוא שורה r ועמודה c. לולאה חיצונית על השורות, פנימית על העמודות. - מכונות מצבים: משתנה אחד (state) שמשתנה לפי כל תו בקלט. טבלה עם עמודות תו, מצב לפני, מצב אחרי.
- קריאות חוזרות: כשפונקציה נקראת עם כמה קלטים, פתרו רק את הקלט שנשאל עליו. השאר הם הסחה.
דוגמה - מעקב אחרי רקורסיה:
static int f(int n) {
if (n <= 1) return 1;
return n + f(n - 2);
}
System.out.println(f(7));
| קריאה | מה קורה | ערך החזרה |
|---|---|---|
| f(1) | תנאי עצירה | 1 |
| f(3) | 3 + f(1) | 4 |
| f(5) | 5 + f(3) | 9 |
| f(7) | 7 + f(5) | 16 |
הפלט: 16. הטבלה כתובה מלמטה למעלה בכוונה: קודם יורדים עד העצירה, ורק אחר כך אפשר למלא את הערכים.
אסטרטגיה לרמה זו
- לפני שמתחילים לעקוב, קראו את הקוד פעם אחת רק כדי להבין מה הוא מנסה לעשות. לפעמים זה חוסך את רוב המעקב (למשל: "זה מחשב סכום ספרות").
- אל תסמכו על התבנית שזיהיתם. אחרי שיש לכם ניחוש, אמתו אותו במעקב מלא של לפחות שני צעדים.
- בשאלות תרחיש, פתחו את הקוד אחרי הטקסט: הטקסט אומר מה שואלים, הקוד אומר מה קורה.
הטעות הכי יקרה ברמה זו היא לוותר באמצע מעקב ולבחור את התשובה "שנראית הכי הגיונית". המסיחים כאן נבנו בדיוק מהמעקבים שנעצרו שלב אחד מוקדם מדי.
רוצים קודם לבדוק איפה אתם עומדים במבחן להב?
מבחן לדוגמה חינם - 10 שאלות עם פתרון מלאקריאה נוספת
- מחשבון קרב במיון: איך עובד המודול ואיך פותרים אותו בטבלת מעקב
מה זה מחשבון קרב, איך נראית שפת התכנות המומצאת שבו, ואיך פותרים כל שאלה בשיטת טבלת המעקב שורה אחר שורה, עם שתי דוגמאות פתורות.
- ממר"ם, בסמ"ח ומצו"ב: המדריך המלא למיון מקצועות המחשב
מיון מקצועות המחשב (מיון תקשוב, מיון ממר"ם) הוא יום אחד שמזין את מצו"ב, ממר"ם ובסמ"ח. אילו מבחנים בו, מי מוזמן, איך המסלולים שונים, טעויות נפוצות ותוכנית תרגול.
- בינארי במיון תקשוב - מדריך מלא ממיר ראשון ועד יום המבחן
המרת בינארי-עשרוני בשני הכיוונים, שלילה דו-משלימה, פעולות חשבון בינאריות, וכל הטריקים שמקצרים את זמן הפתרון.