שפה מומצאת

בחרו רמת קושי וסט תרגול

📖שפה מומצאת — סקירה כללית

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

מה בודק המבחן?

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

הגישה שלנו

בערכה זו אנחנו משתמשים ב-Z80 Assembly — שפת אסמבלי אמיתית אך לא מוכרת לרוב האנשים. זו שפה של מעבד מחשב (Zilog Z80) מ-1976, שעדיין נלמדת כדוגמה קלאסית לשפת מכונה.

למה Z80? כי היא:

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

חשוב: במבחן האמיתי השפה תהיה שונה! המטרה היא לתרגל את תהליך הלמידה — קריאת הוראות, הבנתן, ויישום מהיר.

גישה מומלצת

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

רשימת בדיקה לפני מבחן

✅ קראתי את כל המדריך
✅ פתרתי לפחות 5 שאלות ברמה קלה בהצלחה
✅ פתרתי לפחות 5 שאלות ברמה בינונית
✅ ניסיתי שאלות ברמה קשה
✅ אני יודע מהן הטעויות הנפוצות שלי

זכרו: ההכנה הטובה ביותר היא תרגול + ניתוח טעויות. לא רק לפתור — אלא להבין למה טעיתם ומה לשנות.

📋מדריך מלא — שפה מומצאת

מהי שפת Assembly?

שפת Assembly (אסמבלי) היא שפת תכנות ברמה נמוכה — כל פקודה מבצעת פעולה בסיסית אחת. בניגוד לשפות כמו Python או Java, אין כאן לולאות מובנות או פונקציות מורכבות — הכול נבנה מפקודות פשוטות.

רגיסטרים — "המשתנים" של Assembly

רגיסטר הוא תא זיכרון קטן בתוך המעבד. ב-Z80 יש מספר רגיסטרים:

רגיסטר	שם	תפקיד
`A`	Accumulator (צובר)	הרגיסטר הראשי — רוב הפעולות עובדות איתו
`B`	General Purpose	רגיסטר כללי לשימוש חופשי
`C`	General Purpose	רגיסטר כללי לשימוש חופשי
`D`	General Purpose	רגיסטר כללי לשימוש חופשי
`E`	General Purpose	רגיסטר כללי לשימוש חופשי

כל רגיסטר הוא 8-bit — מכיל ערך בין 0 ל-255.

טבלת פקודות מלאה

פקודה	תחביר	הסבר	דוגמה
`LD`	`LD X, N` / `LD X, Y`	טעינת ערך לרגיסטר. `LD A, 5` שם 5 ב-A. `LD A, B` מעתיק את B ל-A.	`LD A, 5` → A=5
`ADD`	`ADD A, X`	חיבור: A = A + X. התוצאה תמיד נשמרת ב-A.	`ADD A, B` → A=A+B
`SUB`	`SUB X`	חיסור: A = A - X. התוצאה נשמרת ב-A.	`SUB B` → A=A-B
`INC`	`INC X`	הוספת 1: X = X + 1	`INC A` → A=A+1
`DEC`	`DEC X`	הפחתת 1: X = X - 1	`DEC B` → B=B-1
`AND`	`AND X`	AND ביטי: A = A AND X. כל ביט — 1 רק אם שני הביטים 1.	`AND B` → A=A AND B
`OR`	`OR X`	OR ביטי: A = A OR X. כל ביט — 1 אם לפחות ביט אחד 1.	`OR B` → A=A OR B
`XOR`	`XOR X`	XOR ביטי: A = A XOR X. כל ביט — 1 אם הביטים שונים.	`XOR B` → A=A XOR B
`CP`	`CP X`	השוואה: מחשב A-X ומעדכן דגלים, אבל לא משנה את A.	`CP B` → דגלים מעודכנים
`JP Z, label`	—	קפיצה מותנית: קופץ ל-label אם דגל Zero דלוק (תוצאה אחרונה = 0).	`JP Z, done`
`JP NZ, label`	—	קפיצה אם דגל Zero כבוי (תוצאה אחרונה ≠ 0).	`JP NZ, loop`
`JP C, label`	—	קפיצה אם דגל Carry דלוק (A < X בהשוואה, או גלישה).	`JP C, end`
`JP label`	—	קפיצה ללא תנאי — תמיד קופץ.	`JP start`
`CALL label`	—	קריאה לתת-שגרה: שומר את הכתובת הנוכחית וקופץ ל-label.	`CALL multiply`
`RET`	—	חזרה מתת-שגרה: חוזר לנקודה שממנה בוצע CALL.	`RET`
`PUSH BC`	—	שמירה במחסנית: דוחף את B ו-C למחסנית (שומר ערכים).	`PUSH BC`
`POP BC`	—	שחזור מהמחסנית: שולף ערכים מהמחסנית ל-B ו-C.	`POP BC`
`HALT`	—	עצירת התוכנית.	`HALT`

דגלים (Flags)

דגלים הם ביטים מיוחדים שמעודכנים אוטומטית אחרי פעולות חשבוניות:

דגל	שם	מתי נדלק	דוגמה
Z	Zero	כשתוצאת הפעולה היא 0	`SUB A` (A-A=0) → Z=1
C	Carry	כש-A < הערך המושווה (ב-CP), או גלישה מעל 255	`CP 10` כש-A=5 → C=1 (כי 5<10)

חשוב: הפקודה CP היא כמו SUB אבל בלי לשנות את A. היא רק מעדכנת את הדגלים. זה הכלי שמשתמשים בו כדי "לשאול שאלות" — האם A שווה ל-X? האם A גדול מ-X?

דוגמה מפורטת 1: חיבור שני מספרים

    LD A, 8      ; A = 8
    LD B, 5      ; B = 5
    ADD A, B     ; A = A + B = 8 + 5 = 13
    HALT         ; עצירה. A = 13

מעקב:

שורה	A	B	הסבר
LD A, 8	8	—	טוענים 8 ל-A
LD B, 5	8	5	טוענים 5 ל-B
ADD A, B	13	5	A = 8 + 5
HALT	13	5	סיום. תוצאה: A=13

דוגמה מפורטת 2: ספירה לאחור עם לולאה

    LD B, 3       ; B = 3 (מונה)
    LD A, 0       ; A = 0 (סכום)
loop:
    ADD A, B      ; A = A + B
    DEC B         ; B = B - 1
    JP NZ, loop   ; אם B ≠ 0, חזור ל-loop
    HALT          ; עצירה

מעקב:

סיבוב	A (לפני ADD)	B (לפני DEC)	A (אחרי ADD)	B (אחרי DEC)	Z?	קופץ?
1	0	3	3	2	לא	כן → loop
2	3	2	5	1	לא	כן → loop
3	5	1	6	0	כן	לא → HALT

תוצאה: A = 6 (= 3 + 2 + 1), B = 0. התוכנית חישבה את הסכום 1+2+3.

דוגמה מפורטת 3: השוואה עם CP

    LD A, 7       ; A = 7
    LD B, 10      ; B = 10
    CP B          ; משווה: A - B = 7 - 10 = -3
                  ; Z=0 (תוצאה ≠ 0), C=1 (A < B)
    JP C, smaller ; C דלוק → קופצים ל-smaller
    LD C, 1       ; (לא מגיעים לכאן)
    JP done
smaller:
    LD C, 0       ; C = 0 (כי A < B)
done:
    HALT          ; A=7, B=10, C=0

התוכנית בודקת אם A < B. כיוון ש-7 < 10, דגל C נדלק, והתוכנית קופצת ל-smaller.

סיכום וטיפים נוספים

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

רשימת בדיקה לפני מעבר הלאה

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

💡טיפים לשפה מומצאת

1. קראו את כל ההוראות לפני שמתחילים

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

2. בנו טבלת ייחוס מהירה

אחרי קריאה ראשונה, רשמו לעצמכם "צ'יט שיט" מקוצר:

LD = טען ערך
ADD = חבר ל-A
SUB = חסר מ-A
CP = השווה (בלי לשנות)
JP Z = קפוץ אם 0
JP NZ = קפוץ אם לא 0
JP C = קפוץ אם A < X

3. עקבו פקודה אחרי פקודה

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

4. שימו לב לדגלים

הדגלים מעודכנים אחרי כל פעולה חשבונית. כש-JP Z מופיע — שאלו: "מה הפעולה האחרונה? האם התוצאה הייתה 0?"

5. תת-שגרות — עצרו ועקבו

כש-CALL מופיע — סמנו היכן אתם, עברו לתת-השגרה, עקבו עד RET, וחזרו. אם יש PUSH/POP — רשמו מה נשמר במחסנית.

הטעות הנפוצה ביותר: לשכוח ש-CP לא משנה את A. אחרי CP B, הערך של A נשאר אותו דבר — רק הדגלים משתנים.

סיכום — 5 הטיפים המרכזיים

קראו הוראות פעמיים — 50% מהטעויות נובעות מקריאה חפוזה
כתבו כל שלב — אל תסמכו על הזיכרון תחת לחץ
בנו טבלת מעקב — לכל שאלה עם מספר שלבים
בדקו סבירות — האם התשובה הגיונית?
נהלו זמן — 2 דקות מקסימום. אם נתקעתם — סמנו ועברו

תוכנית תרגול של 7 ימים

יום	פעילות	זמן
1	קריאת המדריך המלא + תרגול בסיסי	30 דקות
2	תרגול רמה קלה — 10 שאלות	20 דקות
3	ניתוח טעויות + תרגול נוסף רמה קלה	25 דקות
4	תרגול רמה בינונית — 8 שאלות	30 דקות
5	ניתוח טעויות + תרגול נוסף רמה בינונית	30 דקות
6	תרגול רמה קשה — 5 שאלות	30 דקות
7	סימולציה מלאה בתנאי זמן + ניתוח	45 דקות