סימולציית כנס גאמא — NOVA + CommandBridge
סימולציית כנס גאמא: שפה מומצאת + פרוטוקול מומצא
שיעור השיא. שלבים 11–13 נתנו לך כלים — שיעור זה מרכיב הכל: שפת NOVA מלאה עם 20 שאלות, פרוטוקול CommandBridge עם 15 שאלות, ואסטרטגיית ניהול זמן לכנס האמיתי.
- אסטרטגיית ניהול זמן — 3 סיבובים, 3 דק׳/שאלה, שיטת סימון ?
- שפת NOVA — Variables, Loops (כולל y!), Functions, Arrays, Recursion
- Dry Run שאלות NOVA — מעקב אחרי ערכים, Integer Division, STOP/SKIP
- CommandBridge Protocol — Header 8 bytes, Checksum, Flags bitmask
- State Machine — OFFLINE↔ONLINE, Invalid Transitions
- חישוב Checksum — SUM(header 0-6 + payload) % 256
- ניתוח Packets — פירוק כל שדה, זיהוי שגיאות
- Full Flow — CONNECT → ACK → DATA → ACK
קריטריון מעבר: 75%+ = קרוב מאוד למעבר · 85%+ = מצוין
ניהול זמן — אסטרטגיית 3 שעות
ניהול זמן הוא מיומנות נפרדת. מועמד שיודע הכל אך מנהל זמן גרוע — ייכשל. מועמד שיודע 80% עם ניהול זמן מעולה — יעבור.
הקצאת זמן מומלצת
| שלב | משימה | זמן | הערות |
|---|---|---|---|
| 0 | סרוק שני המפרטים | 8–10 דק׳ | אל תפתור עדיין! |
| 1 | מפרט שפה — מלא Pattern Table | 5–7 דק׳ | על טיוטה |
| 2 | מפרט פרוטוקול — מלא Offset Table | 5–7 דק׳ | על טיוטה |
| 3 | שאלות שפה (20) | 55–65 דק׳ | ~3 דק׳/שאלה |
| 4 | שאלות פרוטוקול (15) | 45–55 דק׳ | ~3 דק׳/שאלה |
| 5 | חזרה על שאלות ? | 15–20 דק׳ | שאלות שסומנו |
| 6 | בדיקה סופית | 10 דק׳ | Checksum + פלטים |
טקטיקת 3 סיבובים
| סיבוב | אילו שאלות | זמן | מטרה |
|---|---|---|---|
| 1 | קלות ובינוניות | 60% | צבור נקודות מהירות, בנה ביטחון |
| 2 | קשות עם גישה חלקית | 30% | גם פתרון חלקי מרוויח |
| 3 | שאלות עם ? | 10% | ניחוש מושכל — לעולם לא תגיש ריק! |
שפת NOVA — Dry Run ותרגול
שפת NOVA היא שפה אימפרטיבית עם Typing חזק. הנקודות הקריטיות: Integer Division, LOOP כולל TO, STOP=break, SKIP=continue, פרמטרים By Value.
Pattern Table — NOVA v1.0
| פעולה | Syntax ב-NOVA | הערה קריטית |
|---|---|---|
| Assignment | SET x = value | — |
| הדפסה | SAY expr | תמיד שורה חדשה |
| תנאי | IF (cond) DO ... END | — |
| LOOP ספירה | LOOP i FROM x TO y DO ... END | כולל y! |
| WHILE | WHILE (cond) DO ... END | — |
| BREAK | STOP | לא break! |
| CONTINUE | SKIP | לא continue! |
| חלוקה | SET d = a / b | Integer Division! |
| חיבור strings | str1 JOIN str2 | — |
| פונקציה | DEFINE name(p) ... RETURN v END | By Value |
| מערך | SET arr = ARRAY[v1, v2] | arr[i] | אינדקס מ-0! |
## ─── 5 מלכודות NOVA שמכשילות הכי הרבה ───────────────────
## 1) LOOP FROM 1 TO 5 = כמה פעמים?
LOOP i FROM 1 TO 5 DO
SAY i ## מדפיס: 1 2 3 4 5 ← 5 פעמים (כולל 5!)
END
## 2) Integer Division:
SET d = 10 / 3 ## d = 3, לא 3.33!
SET e = 7 / 2 ## e = 3, לא 3.5!
## 3) STOP vs SKIP:
LOOP i FROM 1 TO 10 DO
IF (i == 5) DO SKIP END ## דלג על 5, המשך
IF (i == 8) DO STOP END ## עצור לגמרי
SAY i
END ## מדפיס: 1 2 3 4 6 7
## 4) Recursion base case חסר:
## power(5, -1) → אינסוף רקורסיה! (Stack Overflow)
## 5) אינדקס מ-0:
SET arr = ARRAY[10, 20, 30]
SAY arr[0] ## 10 (ראשון)
SAY arr[2] ## 30 (שלישי)
## arr[3] = שגיאה! אינדקס מחוץ לטווחSET x = 3
SET y = 7
SET z = x * y - 2
IF (z > 20) DO
SET z = z / 2
SAY z
ELSE DO
SET z = z + x
SAY z
END
SAY x JOIN " " JOIN TOSTR(z)מה ה-output המלא?SET total = 0
SET count = 0
LOOP i FROM 1 TO 10 DO
IF (i % 2 == 0) DO
SET total = total + i
SET count = count + 1
END
END
SAY total
SAY count
SAY total / countמה ה-output?DEFINE power(base, exp)
IF (exp == 0) DO
RETURN 1
END
RETURN base * power(base, exp - 1)
END
SAY power(2, 0)
SAY power(3, 2)
SAY power(2, 5)מה ה-output? ומה קורה ל-power(5, -1)?- Dry Run = טבלת משתנים. שורה לכל משתנה, ערך חדש בכל שינוי.
- חילוק ב-NOVA הוא Integer Division — השארית נזרקת.
- LOOP i FROM a TO b כולל את b.
- רקורסיה בלי תנאי עצירה שמתקיים = לולאה אינסופית.
CommandBridge Protocol v2.0
פרוטוקול פיקוד ובקרה. Header של 8 bytes עם Checksum. State Machine: OFFLINE → ONLINE. כל שאלת פרוטוקול מתחילה מ-Offset Table.
Offset Table — CommandBridge v2.0
| Offset | Size | Field | ערכים |
|---|---|---|---|
| 0 | 1 | Magic | 0xCB תמיד! |
| 1 | 1 | Command | 0x01=CONNECT, 0x02=DATA, 0x03=ACK, 0x04=PING, 0x05=PONG, 0xFF=ERROR |
| 2 | 1 | NodeID | 0–255 |
| 3-4 | 2 (Big-Endian) | MsgID | 0x0000–0xFFFF |
| 5 | 1 | PayLen | 0–64 bytes |
| 6 | 1 | Flags | bit0=REPLY, bit1=BROADCAST, bit2=ENCRYPTED, bits3-7=Reserved(0!) |
| 7 | 1 | Checksum | SUM(bytes 0-6 + payload) % 256 |
| 8+ | var | Payload | עד 64 bytes |
# ─── 5 מלכודות CommandBridge שמכשילות הכי הרבה ──────────
# 1) Payload נשכח מChecksum:
# Checksum = SUM(bytes 0-6 + PAYLOAD bytes) % 256
# שכחת payload → Checksum שגוי!
# 2) Big-Endian MsgID:
# bytes 3-4: 0x00 0x02 = MsgID=2 (לא 0x0200=512!)
# 3) Reserved bits:
# Flags=0x08 → bit3=1 → Reserved → INVALID PACKET! (R3)
# 4) State Machine — DATA כשOFFLINE:
# Node שולח DATA לפני CONNECT+ACK → INVALID (R4)
# 5) PayLen=64 חוקי:
# R2: "PayLen ≤ 64". גבול עליון כולל! 64 = חוקי.
# ─── State Machine ──────────────────────────────────────
# OFFLINE → ONLINE: Node שולח CONNECT → Controller שולח ACK
# ONLINE → OFFLINE: קבלת ERROR מController, או timeout
# Invalid: DATA/PING כשOFFLINE → שגיאה
# Invalid: CONNECT כשONLINE → Controller שולח ERROR
# ─── דוגמת חישוב Checksum ─────────────────────────────
# P1: CB 01 0A 00 01 00 00 ?? (CONNECT, Node 10, MsgID=1)
# SUM bytes 0-6: CB+01+0A+00+01+00+00
# = 203+1+10+0+1+0+0 = 215 = 0xD7
# PayLen=0 → payload ריק → Checksum = 215 % 256 = 0xD7
# P1 מלא: CB 01 0A 00 01 00 00 D7CB 02 0A 00 02 03 00 ?? עם payload: 41 42 43. מה ה-Checksum?Dry Run מלא + סיכום
שאלות מסכמות בסגנון מיון גאמא — שפה + פרוטוקול ביחד, תחת לחץ זמן.
## ─── Program: Mystery Function ─────────────────────────────
DEFINE mystery(arr)
SET n = LEN(arr)
SET i = 0
SET j = n - 1
WHILE (i < j) DO
SET temp = arr[i]
SET arr[i] = arr[j]
SET arr[j] = temp
SET i = i + 1
SET j = j - 1
END
RETURN arr
END
SET data = ARRAY[1, 2, 3, 4, 5]
SET result = mystery(data)
LOOP k FROM 0 TO LEN(result) - 1 DO
SAY result[k]
END
## ─── ניתוח: מה עושה mystery? ────────────────────────────────
## n=5, i=0, j=4
## איטרציה 1 (i=0,j=4): SWAP arr[0]↔arr[4] → [5,2,3,4,1], i=1, j=3
## איטרציה 2 (i=1,j=3): SWAP arr[1]↔arr[3] → [5,4,3,2,1], i=2, j=2
## i<j → 2<2 FALSE → לולאה מסתיימת
## result = [5,4,3,2,1]
## Output: 5 / 4 / 3 / 2 / 1
## mystery = REVERSE (היפוך מערך) — Two-Pointer Algorithm!- ניהול זמן: 3 סיבובים, 3 דק׳/שאלה, סמן ? ועבור, לעולם לא משאירים ריק
- NOVA — LOOP FROM x TO y כולל y! Integer Division! STOP=break, SKIP=continue, arr[0]=ראשון
- Recursion: תמיד בדוק base case עם הקלט הנתון — exp שלילי = אינסוף
- CommandBridge: Header 8 bytes, Checksum = SUM(0-6 + payload) % 256
- Flags bitmask: bit0=REPLY, bit1=BROADCAST, bit2=ENCRYPTED, bits3-7 חייבים 0!
- State Machine: OFFLINE→ONLINE על CONNECT+ACK. CONNECT כשONLINE = ERROR
- MsgID: Big-Endian! 0x00 0x02 = 2 (לא 512). ACK עם אותו MsgID כDATA
- PayLen=64 = חוקי! R2 אומר "0-64 כולל"
□ מסוגל לפרסר Flags byte bit-by-bit תוך 15 שניות
□ מסוגל לעקוב אחרי לולאת NOVA של 10 איטרציות ב-2 דקות
□ מכיר Pattern Table ויכול למלא אותה ב-3 דקות
□ מכיר Offset Table ויכול למלא אותה ב-3 דקות
□ ניסיתי אסטרטגיית 3 הסיבובים ותרגלתי אותה
SET nums = ARRAY[5, 3, 8, 1, 9, 2, 7]
SET maxVal = nums[0]
SET maxIdx = 0
LOOP i FROM 1 TO LEN(nums) - 1 DO
IF (nums[i] > maxVal) DO
SET maxVal = nums[i]
SET maxIdx = i
END
END
SAY maxVal
SAY maxIdx
SAY nums[maxIdx - 1]מה ה-output?CB 02 05 00 01 01 08 ??. האם הPacket חוקי?אתגר מעשי — סימולציית כנס: NOVA ו-CommandBridge
שיא השיעור: לבנות ולתקן מערכות אמיתיות — מפרשים, פרוטוקולים, מכונות. פתרו את החובה ואז את האתגר; ההגשה נבדקת אוטומטית מול מקרי-קצה נסתרים.
שאלות תרגול ותשובות (10)
שאלה 1.1 — ניהול זמן · נותרו 45 דקות ו-12 שאלות לא פתורות (מתוכן 4 קשות). מה הסדר הנכון?
- א. קודם הקלות והבינוניות, ואז הקשות בזמן שנשאר
- ב. קודם ארבע הקשות — הן שוות יותר נקודות
- ג. לפי הסדר המספרי ברשימה
- ד. לוותר על הקשות ולמקד רק בקלות
✓ תשובה: א) 8 קלות → 4 קשות → ניחוש — זוהי טקטיקת 3 הסיבובים. סיבוב 1 (60% זמן): קלות → נקודות בטוחות + ביטחון. סיבוב 2 (30%): קשות → גם חלקי = רווח. סיבוב 3 (10%): ניחוש מושכל — לעולם לא משאירים ריק! ניחוש = 25% סיכוי ב-4 אפשרויות.
שאלה 1.3 — Pattern Table · למה ממלאים Pattern Table ו-Offset Table לפני פתרון השאלות?
## ─── 5 מלכודות NOVA שמכשילות הכי הרבה ───────────────────
## 1) LOOP FROM 1 TO 5 = כמה פעמים?
LOOP i FROM 1 TO 5 DO
SAY i ## מדפיס: 1 2 3 4 5 ← 5 פעמים (כולל 5!)
END
## 2) Integer Division:
SET d = 10 / 3 ## d = 3, לא 3.33!
SET e = 7 / 2 ## e = 3, לא 3.5!
## 3) STOP vs SKIP:
LOOP i FROM 1 TO 10 DO
IF (i == 5) DO SKIP END ## דלג על 5, המשך
IF (i == 8) DO STOP END ## עצור לגמרי
SAY i
END ## מדפיס: 1 2 3 4 6 7
## 4) Recursion base case חסר:
## power(5, -1) → אינסוף רקורסיה! (Stack Overflow)
## 5) אינדקס מ-0:
SET arr = ARRAY[10, 20, 30]
SAY arr[0] ## 10 (ראשון)
SAY arr[2] ## 30 (שלישי)
## arr[3] = שגיאה! אינדקס מחוץ לטווח- א. כדי לא לחפש שוב במפרט בכל שאלה
- ב. זו דרישה פורמלית של הכנס
- ג. כדי לרשום אילו שאלות כבר נענו
- ד. כדי לזכור את הניקוד של כל שאלה
✓ תשובה: א) — 8-10 דקות לקריאה + 5-7 דקות למילוי טבלה = השקעה שחוזרת כפולה. בלעדיה: כל שאלה על LOOP = חזרה למפרט לבדוק "כולל TO?". עם הטבלה: הכל לפניך בשניות. המועמדים שקורצים על קריאת המפרט מבזבזים פי 3 זמן על שאלות.
שאלה 2.1 — Program Dry Run · SET x = 3 SET y = 7 SET z = x * y - 2 IF (z > 20) DO SET z = z / 2 SAY z ELSE DO SET z = z + x SAY z END SAY x JOIN " " JOIN TOSTR(z)מה ה-output המלא?
SET x = 3
SET y = 7
SET z = x * y - 2
IF (z > 20) DO
SET z = z / 2
SAY z
ELSE DO
SET z = z + x
SAY z
END
SAY x JOIN " " JOIN TOSTR(z)- א. 19, ואז "3 19"
- ב. 9, ואז "3 9"
- ג. 22, ואז "3 22"
- ד. 22, ואז "3 27"
✓ תשובה: ג) — ניתוח: z = 3*7-2 = 21-2 = 19. בדיקה: 19>20? FALSE → ELSE. z = 19+3 = 22. SAY z → "22". SAY x JOIN " " JOIN TOSTR(z) = "3" JOIN " " JOIN "22" = "3 22". Output: 22 / 3 22.
שאלה 2.2 — Loop + Integer Division · SET total = 0 SET count = 0 LOOP i FROM 1 TO 10 DO IF (i % 2 == 0) DO SET total = total + i SET count = count + 1 END END SAY total SAY count SAY total / countמה ה-output?
SET total = 0
SET count = 0
LOOP i FROM 1 TO 10 DO
IF (i % 2 == 0) DO
SET total = total + i
SET count = count + 1
END
END
SAY total
SAY count
SAY total / count- א. 25, 5, 5
- ב. 30, 5, 6
- ג. 30, 4, 7
- ד. 55, 10, 5
✓ תשובה: ב) 30 / 5 / 6 — LOOP FROM 1 TO 10 כולל 10! מספרים זוגיים: 2,4,6,8,10. total=30, count=5. 30/5=6. שים לב: LOOP כולל y=10 — טעות נפוצה היא לחשוב שלא כולל 10. ו-Integer Division = 30/5 = 6 בדיוק כאן.
שאלה 2.3 — Recursion Dry Run · DEFINE power(base, exp) IF (exp == 0) DO RETURN 1 END RETURN base * power(base, exp - 1) END SAY power(2, 0) SAY power(3, 2) SAY power(2, 5)מה ה-output? ומה קורה ל-power(5, -1)?
DEFINE power(base, exp)
IF (exp == 0) DO
RETURN 1
END
RETURN base * power(base, exp - 1)
END
SAY power(2, 0)
SAY power(3, 2)
SAY power(2, 5)- א. 1, 6, 32 — ו-power(5,-1) מחזיר 5-
- ב. 0, 9, 32 — ו-power(5,-1) זורק שגיאה
- ג. 1, 9, 32 — ו-power(5,-1) נכנס לרקורסיה אינסופית
- ד. 1, 9, 32 — ו-power(5,-1) מחזיר 0
✓ תשובה: ג) — power(2,0)=1 (base case). power(3,2)=3*3=9. power(2,5)=32. power(5,-1): exp=-1≠0 → RETURN 5*power(5,-2) → power(5,-3)... לעולם לא מגיע ל-exp==0 → Infinite Recursion → Stack Overflow! זוהי שאלת "מה יקרה" שגאמא אוהבת.
שאלה 3.1 — חישוב Checksum · Packet: CB 02 0A 00 02 03 00 ?? עם payload: 41 42 43. מה ה-Checksum?
CB 02 0A 00 02 03 00 ??
- א. 0xDC
- ב. 0xD7
- ג. 0xC6
- ד. 0xA2
✓ תשובה: ד) 0xA2 — Header bytes 0-6: 0xCB+0x02+0x0A+0x00+0x02+0x03+0x00 = 203+2+10+0+2+3+0 = 220. Payload: 0x41+0x42+0x43 = 65+66+67 = 198. Total = (220+198)%256 = 418%256 = 162 = 0xA2. טעות נפוצה: שכחת לכלול payload ב-Checksum!
שאלה 3.2 — State Machine + Flags · Node 10 שלח CONNECT ב-P1, קיבל ACK ב-P2 (Flags=0x01). עכשיו שולח CONNECT שוב (P9). מה הController יעשה?
- א. יאשר את ה-CONNECT השנייה ב-ACK
- ב. ישלח ERROR — CONNECT במצב ONLINE הוא מעבר לא חוקי
- ג. יתעלם מה-Packet
- ד. ישלח PONG בתגובה
✓ תשובה: ב) ERROR — State Machine: "CONNECT בזמן ONLINE → Controller שולח ERROR". לאחר ACK ב-P2: Node 10 = ONLINE. P9 = CONNECT שוב = Invalid. Controller → ERROR. לאחר ERROR: Node עובר ל-OFFLINE ויצטרך לשלוח CONNECT חדש. גם: Flags=0x01 ב-P2 = REPLY=1 (תגובה) ✓.
שאלה 3.3 — Full Flow: בניית Packets · כתוב Packet חוקי PING מ-Node 15, MsgID=0x0009, ללא payload. מה ה-Checksum?
## ─── Program: Mystery Function ─────────────────────────────
DEFINE mystery(arr)
SET n = LEN(arr)
SET i = 0
SET j = n - 1
WHILE (i < j) DO
SET temp = arr[i]
SET arr[i] = arr[j]
SET arr[j] = temp
SET i = i + 1
SET j = j - 1
END
RETURN arr
END
SET data = ARRAY[1, 2, 3, 4, 5]
SET result = mystery(data)
LOOP k FROM 0 TO LEN(result) - 1 DO
SAY result[k]
END
## ─── ניתוח: מה עושה mystery? ────────────────────────────────
## n=5, i=0, j=4
## איטרציה 1 (i=0,j=4): SWAP arr[0]↔arr[4] → [5,2,3,4,1], i=1, j=3
## איטרציה 2 (i=1,j=3): SWAP arr[1]↔arr[3] → [5,4,3,2,1], i=2, j=2
## i<j → 2<2 FALSE → לולאה מסתיימת
## result = [5,4,3,2,1]
## Output: 5 / 4 / 3 / 2 / 1
## mystery = REVERSE (היפוך מערך) — Two-Pointer Algorithm!- א. 0xE6
- ב. 0xD7
- ג. 0xE7
- ד. 0xE8 (PayLen=0x01)
✓ תשובה: ג) CB 04 0F 00 09 00 00 E7 — Magic=0xCB. Cmd=0x04(PING). NodeID=15=0x0F. MsgID=0x0009 (Big-Endian: 00 09). PayLen=0x00. Flags=0x00 (לא REPLY, לא BROADCAST). SUM: 203+4+15+0+9+0+0=231=0xE7. Payload ריק → Checksum=0xE7.
גאמא סגנון א׳ — NOVA Array · SET nums = ARRAY[5, 3, 8, 1, 9, 2, 7] SET maxVal = nums[0] SET maxIdx = 0 LOOP i FROM 1 TO LEN(nums) - 1 DO IF (nums[i] > maxVal) DO SET maxVal = nums[i] SET maxIdx = i END END SAY maxVal SAY maxIdx SAY nums[maxIdx - 1]מה ה-output?
SET nums = ARRAY[5, 3, 8, 1, 9, 2, 7]
SET maxVal = nums[0]
SET maxIdx = 0
LOOP i FROM 1 TO LEN(nums) - 1 DO
IF (nums[i] > maxVal) DO
SET maxVal = nums[i]
SET maxIdx = i
END
END
SAY maxVal
SAY maxIdx
SAY nums[maxIdx - 1]- א. 9, 4, 9
- ב. 9, 5, 2
- ג. 8, 2, 3
- ד. 9, 4, 1
✓ תשובה: ד) 9 / 4 / 1 — מעקב: nums=[5,3,8,1,9,2,7]. maxVal=5, maxIdx=0. i=1:3>5? לא. i=2:8>5? כן→maxVal=8,maxIdx=2. i=3:1>8? לא. i=4:9>8? כן→maxVal=9,maxIdx=4. i=5:2>9? לא. i=6:7>9? לא. Output: SAY 9, SAY 4, SAY nums[3]=1. מעניין: 1 הוא האלמנט לפני המקסימום, לא המינימום!
גאמא סגנון ב׳ — Flags + Packet Validity · Packet: CB 02 05 00 01 01 08 ??. האם הPacket חוקי?
CB 02 05 00 01 01 08 ??
- א. חוקי — NodeID=5, PayLen=1, Flags תקינים
- ב. חוקי — Flags=0x08 מציין BROADCAST
- ג. לא חוקי — Flags=0x08 מדליק ביט שמור
- ד. לא חוקי — PayLen=1 אינו תקין
✓ תשובה: ג) INVALID — Flags=0x08=00001000. bit0=0(REPLY off), bit1=0(BROADCAST off), bit2=0(ENCRYPTED off), bit3=1 ← Reserved! R3: "Reserved flag bits (3-7) חייבים להיות 0". Bit3=1 = INVALID. גם אם שאר כל השדות תקינים — Packet אחד עם Reserved bit = פסול.