GammaCyber

סימולציית כנס גאמא — NOVA + CommandBridge

תכנות, אלגוריתמיקה ו-Web · 6–8 שעות

// סקירה

סימולציית כנס גאמא: שפה מומצאת + פרוטוקול מומצא

שיעור השיא. שלבים 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
🎯 קשר למיוני גאמא
שיעור זה הוא הכנס עצמו: 3 שעות · אולם מבחנים · 35 שאלות · מפרט שפה + מפרט פרוטוקול · ללא מחשב, ללא אינטרנט
קריטריון מעבר: 75%+ = קרוב מאוד למעבר · 85%+ = מצוין
// פרק 1

ניהול זמן — אסטרטגיית 3 שעות

ניהול זמן הוא מיומנות נפרדת. מועמד שיודע הכל אך מנהל זמן גרוע — ייכשל. מועמד שיודע 80% עם ניהול זמן מעולה — יעבור.

הקצאת זמן מומלצת

שלבמשימהזמןהערות
0סרוק שני המפרטים8–10 דק׳אל תפתור עדיין!
1מפרט שפה — מלא Pattern Table5–7 דק׳על טיוטה
2מפרט פרוטוקול — מלא Offset Table5–7 דק׳על טיוטה
3שאלות שפה (20)55–65 דק׳~3 דק׳/שאלה
4שאלות פרוטוקול (15)45–55 דק׳~3 דק׳/שאלה
5חזרה על שאלות ?15–20 דק׳שאלות שסומנו
6בדיקה סופית10 דק׳Checksum + פלטים

טקטיקת 3 סיבובים

סיבובאילו שאלותזמןמטרה
1קלות ובינוניות60%צבור נקודות מהירות, בנה ביטחון
2קשות עם גישה חלקית30%גם פתרון חלקי מרוויח
3שאלות עם ?10%ניחוש מושכל — לעולם לא תגיש ריק!
הרחבה 5 כלים מנטליים לכנס ›

1) נשימה עמוקה בתחילת המבחן — 3 נשימות מורידות קורטיזול ומפעילות Prefrontal Cortex.

2) "אני מכיר את השיטה" — אתה יודע 5 שלבים. זה כבר יתרון על 80% מהמועמדים.

3) שאלה קשה? זה לא אתה — זו שאלה שנועדה להיות קשה. סמן ? ועבור הלאה.

4) כתוב על טיוטה — Symbol Table, Offset Table, חישובים — הכל על נייר, לא בראש.

5) אחרי שעה — לגום מים, נשום, מתח ידיים. 30 שניות "reset" = שיפור בשעה הבאה.

✏תרגול עצמי3 שאלות
שאלה 1.1 — ניהול זמן
נותרו 45 דקות ו-12 שאלות לא פתורות (מתוכן 4 קשות). מה הסדר הנכון?
✓ תשובה: א) 8 קלות → 4 קשות → ניחוש — זוהי טקטיקת 3 הסיבובים. סיבוב 1 (60% זמן): קלות → נקודות בטוחות + ביטחון. סיבוב 2 (30%): קשות → גם חלקי = רווח. סיבוב 3 (10%): ניחוש מושכל — לעולם לא משאירים ריק! ניחוש = 25% סיכוי ב-4 אפשרויות.
שאלה 1.2 — טעויות זמן
מה הטעות הכי נפוצה בניהול זמן בכנס?
✓ תשובה: ד) תקיעות — 3 דקות לשאלה = קצוב. מועמד שמבלה 15 דקות על שאלה אחת קשה מפסיד 4 שאלות קלות = אסון. הכלל: שאלה בת יותר מ-3 דקות → סמן ? → עבור → חזור בסיבוב 3. כתיבה על טיוטה ב) וקריאת מפרט ג) הם הכרחיים!
שאלה 1.3 — Pattern Table
למה ממלאים Pattern Table ו-Offset Table לפני פתרון השאלות?
✓ תשובה: א) — 8-10 דקות לקריאה + 5-7 דקות למילוי טבלה = השקעה שחוזרת כפולה. בלעדיה: כל שאלה על LOOP = חזרה למפרט לבדוק "כולל TO?". עם הטבלה: הכל לפניך בשניות. המועמדים שקורצים על קריאת המפרט מבזבזים פי 3 זמן על שאלות.
// פרק 2

שפת NOVA — Dry Run ותרגול

שפת NOVA היא שפה אימפרטיבית עם Typing חזק. הנקודות הקריטיות: Integer Division, LOOP כולל TO, STOP=break, SKIP=continue, פרמטרים By Value.

Pattern Table — NOVA v1.0

פעולהSyntax ב-NOVAהערה קריטית
AssignmentSET x = value—
הדפסהSAY exprתמיד שורה חדשה
תנאיIF (cond) DO ... END—
LOOP ספירהLOOP i FROM x TO y DO ... ENDכולל y!
WHILEWHILE (cond) DO ... END—
BREAKSTOPלא break!
CONTINUESKIPלא continue!
חלוקהSET d = a / bInteger Division!
חיבור stringsstr1 JOIN str2—
פונקציהDEFINE name(p) ... RETURN v ENDBy 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] = שגיאה! אינדקס מחוץ לטווח
✏תרגול עצמי — Dry Run NOVA3 שאלות
שאלה 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 המלא?
✓ תשובה: ג) — ניתוח: 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?
✓ תשובה: ב) 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)?
✓ תשובה: ג) — 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! זוהי שאלת "מה יקרה" שגאמא אוהבת.
✓סיכום ביניים — לפני שעוברים לפרוטוקול
  • Dry Run = טבלת משתנים. שורה לכל משתנה, ערך חדש בכל שינוי.
  • חילוק ב-NOVA הוא Integer Division — השארית נזרקת.
  • LOOP i FROM a TO b כולל את b.
  • רקורסיה בלי תנאי עצירה שמתקיים = לולאה אינסופית.
🎯 דגש למבחן — ניהול משתנים בטיוטה
ב-Dry Run מתחו קו על הערך הישן במקום למחוק במחק. כך תוכלו לחזור שלב אחורה אם התבלבלתם, במקום להריץ את כל התוכנית מההתחלה.
// פרק 3

CommandBridge Protocol v2.0

פרוטוקול פיקוד ובקרה. Header של 8 bytes עם Checksum. State Machine: OFFLINE → ONLINE. כל שאלת פרוטוקול מתחילה מ-Offset Table.

Offset Table — CommandBridge v2.0

OffsetSizeFieldערכים
01Magic0xCB תמיד!
11Command0x01=CONNECT, 0x02=DATA, 0x03=ACK, 0x04=PING, 0x05=PONG, 0xFF=ERROR
21NodeID0–255
3-42 (Big-Endian)MsgID0x0000–0xFFFF
51PayLen0–64 bytes
61Flagsbit0=REPLY, bit1=BROADCAST, bit2=ENCRYPTED, bits3-7=Reserved(0!)
71ChecksumSUM(bytes 0-6 + payload) % 256
8+varPayloadעד 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 D7
הרחבה Flags Byte — פירוט כל bit ›
Bitשםערך 1 = ?דוגמה
bit 0REPLYזו תגובהACK מController → Flags=0x01
bit 1BROADCASTלכל הצמתיםNodeID מתעלם
bit 2ENCRYPTEDמוצפן—
bits 3-7ReservedILLEGAL!חייב להיות 0
# ─── Flags חישובים ────────────────────────────────────── # REPLY בלבד: 00000001 = 0x01 # BROADCAST בלבד: 00000010 = 0x02 # ENCRYPTED בלבד: 00000100 = 0x04 # BROADCAST + ENCRYPTED: 00000110 = 0x06 # REPLY + ENCRYPTED: 00000101 = 0x05 # ILLEGAL (bit3=1): 00001000 = 0x08 → INVALID!
✏תרגול עצמי — CommandBridge3 שאלות
שאלה 3.1 — חישוב Checksum
Packet: CB 02 0A 00 02 03 00 ?? עם payload: 41 42 43. מה ה-Checksum?
✓ תשובה: ד) 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 יעשה?
✓ תשובה: ב) 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?
✓ תשובה: ג) 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.
// פרק 4

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!
✓מה למדנו בשיעור 14
  • ניהול זמן: 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 כולל"
🏆 רשימת תיוג לפני הכנס
□ מסוגל לחשב SUM Checksum על 7 bytes תוך 30 שניות
□ מסוגל לפרסר Flags byte bit-by-bit תוך 15 שניות
□ מסוגל לעקוב אחרי לולאת NOVA של 10 איטרציות ב-2 דקות
□ מכיר Pattern Table ויכול למלא אותה ב-3 דקות
□ מכיר Offset Table ויכול למלא אותה ב-3 דקות
□ ניסיתי אסטרטגיית 3 הסיבובים ותרגלתי אותה
✏תרגול סיום — גאמא סגנון3 שאלות
גאמא סגנון א׳ — 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?
✓ תשובה: ד) 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 חוקי?
✓ תשובה: ג) 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 = פסול.
גאמא סגנון ג׳ — Full Flow Checksum
Node 20 (0x14) שולח CONNECT, MsgID=0x0001. Controller שולח ACK (REPLY=1, אותו MsgID). מה ה-Checksum של ה-ACK?
✓ תשובה: א) 0xE4 — ACK Header: Magic=0xCB, Cmd=0x03(ACK), NodeID=0x14(20), MsgID=0x0001(Big-Endian: 00 01), PayLen=0x00, Flags=0x01(REPLY=1). SUM bytes 0-6: 203+3+20+0+1+0+1=228=0xE4. CONNECT Checksum: 203+1+20+0+1+0+0=225=0xE1. הבדל: ACK מוסיף Flags=0x01=REPLY.
// אתגר מעשי

אתגר מעשי — סימולציית כנס: NOVA ו-CommandBridge

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

T2 · בסיסי250 נק'~15 דק'algorithmic
CommandBridge — סמן על רשת
פרוטוקול CommandBridge שולט בסמן על רשת אינסופית, שמתחיל ב-(0,0). כל פקודה: "MOVE DIR K" כאשר DIR הוא N/S/E/W ו-K מספר צעדים (N=+y, S=-y, E=+x, W=-x). עבד את הפקודות והחזר את המיקום הסופי (x, y).
דוגמאות
run_cursor(['MOVE N 3','MOVE E 2']) → (2, 3)
run_cursor(['MOVE N 1','MOVE S 1']) → (0, 0)
הפתרון נשמר מקומית ומשותף עם עמוד „כתיבת קוד”.
פתרון-ייחוס CommandBridge — סמן על רשת ›
def run_cursor(cmds: list[str]) -> tuple[int, int]: x = y = 0 for c in cmds: _, d, k = c.split(); k = int(k) if d == 'N': y += k elif d == 'S': y -= k elif d == 'E': x += k elif d == 'W': x -= k return (x, y)
T3 · בינוני450 נק'~30 דק'algorithmic
NOVA VM — אוגרים ובקרת זרימה
ממש את מכונת NOVA. תוכנית = רשימת הוראות, מונה-פקודות מתחיל ב-0. אוגרים (כל שם מתחיל ב-0). הוראות: "MOV rX n" (rX=n) · "ADD rX n" · "SUB rX n" · "OUT rX" (הוסף לפלט) · "JNZ rX off" (אם rX≠0 קפוץ יחסית ב-off, אחרת המשך). החזר את רשימת ה-OUT. (המימוש חייב לתמוך בלולאות דרך JNZ; הגן מלולאה אינסופית בתקרת צעדים.)
דוגמאות
run_nova(['MOV r0 3','OUT r0','SUB r0 1','JNZ r0 -2']) → [3, 2, 1] # לולאת ספירה-לאחור
run_nova(['MOV r0 5','OUT r0','ADD r0 2','OUT r0']) → [5, 7]
הפתרון נשמר מקומית ומשותף עם עמוד „כתיבת קוד”.
פתרון-ייחוס NOVA VM — אוגרים ובקרת זרימה ›
def run_nova(program: list[str]) -> list: reg = {}; out = []; i = 0; steps = 0; LIMIT = 10**6 while 0 <= i < len(program): steps += 1 if steps > LIMIT: break # הגנה מלולאה אינסופית p = program[i].split(); op = p[0] if op == 'MOV': reg[p[1]] = int(p[2]); i += 1 elif op == 'ADD': reg[p[1]] = reg.get(p[1], 0) + int(p[2]); i += 1 elif op == 'SUB': reg[p[1]] = reg.get(p[1], 0) - int(p[2]); i += 1 elif op == 'OUT': out.append(reg.get(p[1], 0)); i += 1 elif op == 'JNZ': i += int(p[2]) if reg.get(p[1], 0) != 0 else 1 else: i += 1 return out
שאלות תרגול ותשובות (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 = פסול.