שפה מומצאת — 5 שלבים, Dry Run, Symbol Table

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

⌨ כתיבת קוד (2)תרגילים ומשימות קוד לשיעור 11

// סקירה

שפה מומצאת — המחשבון קרב

שיעור זה הוא הכי חשוב בקורס לכנס המבחנים. מחשבון הקרב = שפה שמעולם לא ראית + קוד + 20 שאלות + 45 דקות לחץ. מי שיש לו מתודולוגיה = עובר. מי שמנסה "לנחש" = נכשל.

✓נושאי השיעור

5 השלבים — סקר מהיר → מיפוי → Trace דוגמה → Dry Run → ניהול זמן
Pattern Recognition — 8 Building Blocks בכל שפה, טבלת operators
Symbol Table — כלי החובה לכל Dry Run: מבנה, לולאות, לולאות מקוננות
Dry Run — ביצוע ידני שורה-שורה: Zenith, Kova, NovaCal
Stack Frames — Frame לכל פונקציה, עץ קריאות לרקורסיה
שפת Zenith — LET, FOR/END FOR, IF THEN/END IF, FUNC, PRINT
שפת Kova — var, :=, @, @@, ?, fn, >>
שפת NovaCal — Assembly-style: STORE, LOAD, ADD, SAVE, IFGT, JUMP
ניהול זמן — 3 דקות max, סמן ועבור, חזור בסוף

🔴 קריטי — קרא לפני הכל

מחשבון הקרב זה לא בדיקת ידע Python. זה בדיקת יכולת חשיבה לוגית תחת לחץ. שאלות מסוג: "מה הפלט?", "מה ערך X בשורה Y?", "כמה פעמים רצה הלולאה?" — 5 שלבים + Dry Run + Symbol Table = הנשק שלך.

// פרק 1

5 השלבים: המתודולוגיה המדעית

כל מועמד שמגיע ל-Gamma Computer Test ללא מתודולוגיה — מאבד זמן. כל מועמד עם 5 השלבים — יודע מה לעשות בכל רגע נתון.

שלב	שם	מה עושים	זמן מומלץ
1	סקר מהיר	קרא את כל המפרט פעם אחת ללא עצירה. מטרה: "מה יש כאן?"	5-7 דקות
2	מיפוי Pattern	זהה: Assignment? לולאה? תנאי? פונקציה? מלא טבלת Pattern	3-5 דקות
3	Trace דוגמה	מצא קטע קוד פשוט במפרט ו-trace אותו ידנית — ודא שהבנת	5-7 דקות
4	Dry Run + Symbol Table	לכל שאלה: בנה Symbol Table, עקוב שורה-שורה, ענה	2-3 דקות/שאלה
5	ניהול זמן	שאלה קשה יותר מ-3 דקות? סמן ועבור הלאה. חזור בסוף.	תמידי

! לא לפרש לפי Python! ›

הטעות הנפוצה ביותר: מיד "מתרגמים" את השפה המומצאת לPython בראש.
LOOP i FROM 1 TO 5 — מיד: "זה for i in range(1,5)" — אבל TO 5 כולל 5 או לא? חייב לבדוק בדוגמאות המפרט!
כלל: אל תניח — ודא. בדוק תמיד בדוגמות המפרט אם הגבול כולל או לא.

טבלת Pattern — מלא בכנס

פעולה	Syntax בשפה זו
Assignment	??
הדפסה	??
תנאי (if)	??
לולאה ספירה	??
לולאה תנאי (while)	??
הגדרת פונקציה	??
גישה למערך	??
שוויון (==)	??

✏תרגול עצמי3 שאלות

שאלה 1.1

מה הצעד הראשון שצריך לעשות כשנכנסים לכנס ורואים שפה מומצאת?

✓ תשובה: ד) — שגיאה קלאסית: להתחיל שאלה 1 ללא מפרט. 7 דקות קריאה = חוסכים 20 דקות בשאלות. סקר מהיר → מיפוי → Trace דוגמה → רק אז שאלות.

שאלה 1.2

מדוע לעשות Trace על דוגמת הקוד שבמפרט לפני השאלות?

✓ תשובה: ב) — Trace דוגמה = ודאות שParsing שלך נכון. אם מצאת תוצאה שגויה → חזור לשלב 2 לפני שמבזבז זמן בשאלות. המפרט תמיד נכון בגאמא.

שאלה 1.3

רואית בשפה מומצאת: IF a EQ b AND NOT c GT 5 — מה השקול ב-Python?

✓ תשובה: ג) — EQ→==, AND→and, NOT→not, GT→>. if a == b and not c > 5. not c > 5 = c לא גדול מ-5 = c <= 5. כלל: ברגע שמזהים operators — ממירים לPython וממשיכים.

// פרקים 3–4

Symbol Table: הכלי המרכזי

Symbol Table = טבלה שרושמים בה כל משתנה ואת הערך הנוכחי שלו בכל נקודת זמן. בלי Symbol Table = שוכחים ערכים → תשובות שגויות.

Dry Run על שפת Zenith — דוגמה מלאה

Zenith Language — Snippet

LET sum = 0
LET count = 0
FOR i = 1 TO 10
    IF i MOD 2 = 0 THEN
        SET sum TO sum + i
        SET count TO count + 1
    END IF
END FOR
PRINT sum
PRINT count

📋 Symbol Table — Dry Run

i MOD 2 = 0 → i זוגי. לולאה i=1..10:

i=2: sum=0+2=2, count=1 | i=4: sum=2+4=6, count=2 | i=6: sum=6+6=12, count=3 | i=8: sum=12+8=20, count=4 | i=10: sum=20+10=30, count=5

פלט: PRINT sum → 30 | PRINT count → 5

מה עושה הקוד? → מחשב סכום ומספר המספרים הזוגיים בטווח 1–10.

Symbol Table ללולאות מקוננות

Zenith — Nested Loops

SET count TO 0
LOOP i FROM 1 TO 3
    LOOP j FROM 1 TO i
        ADD count BY 1
    ENDLOOP
ENDLOOP
OUTPUT count

📋 Symbol Table — Nested

i=1 → j רץ 1 פעם (count=1) | i=2 → j רץ 2 פעמים (count=3) | i=3 → j רץ 3 פעמים (count=6)
פלט: 6 | נוסחה: 1+2+3 = n*(n+1)/2 = 3*4/2 = 6

🎯 שאלת גאמא קלאסית

"כמה פעמים רץ הגוף הפנימי?" עבור LOOP i FROM 1 TO n / LOOP j FROM 1 TO i — נוסחה: n*(n+1)/2. n=3: 6. n=5: 15. n=10: 55.

הרחבה Bubble Sort בשפת Zenith — ניתוח מלא ›

Zenith — Bubble Sort

LET arr[5]
SET arr[0] TO 3  SET arr[1] TO 1  SET arr[2] TO 4
SET arr[3] TO 1  SET arr[4] TO 5

LET n = arr.SIZE
FOR i = 0 TO n-2
    FOR j = 0 TO n-2-i
        IF arr[j] > arr[j+1] THEN
            LET tmp = arr[j]
            SET arr[j] TO arr[j+1]
            SET arr[j+1] TO tmp
        END IF
    END FOR
END FOR

FOR k = 0 TO n-1
    PRINT arr[k]
END FOR

arr=[3,1,4,1,5], n=5. זה Bubble Sort! Pass 1 (i=0): j=0: swap(3,1)→[1,3,4,1,5], j=2: swap(4,1)→[1,3,1,4,5]. Pass 2 (i=1): j=1: swap(3,1)→[1,1,3,4,5]. Pass 3,4: כבר ממוין. פלט: 1 1 3 4 5

✏תרגול עצמי3 שאלות

שאלה 3.1 — Zenith

Zenith — FOR i=3 TO 3: כמה פעמים ירוץ הגוף?

✓ תשובה: ד) 1 — ב-Zenith, TO 5 כולל 5. FOR i=3 TO 3: i=3 עומד בתנאי 3<=3 → גוף רץ פעם אחת. זה שונה מ-Python range(3,3) = 0 פעמים!

שאלה 3.2 — Zenith Dry Run

LET x = 1
FOR i = 1 TO 4
  SET x TO x * 2
END FOR
PRINT x

מה הפלט?

✓ תשובה: ב) 16 — Symbol Table: x=1→2→4→8→16. i=1,2,3,4 → 4 iterations → x מוכפל 4 פעמים → 1*2⁴=16.

שאלה 3.3 — Nested loops

FOR i=1 TO 4, FOR j=i+1 TO 4. כמה iterations בגוף הפנימי?

✓ תשובה: א) 6 — i=1: j=2,3,4 (3). i=2: j=3,4 (2). i=3: j=4 (1). i=4: j=5>4 (0). סה"כ: 3+2+1+0=6. נוסחה: n*(n-1)/2 = 4*3/2 = 6.

🎯 דגש למבחן

לולאות מקוננות: אל תסמכו על נוסחה — בדקו את הגבולות. נוסחאות כמו n(n+1)/2 או n(n−1)/2 נכונות רק לתבנית מדויקת. שלוש שאלות לפני שמציבים בנוסחה: (1) האם הגבול כולל את הקצה (TO 10 בזניט כולל את 10, range(10) בפייתון לא)? (2) האם הלולאה הפנימית תלויה ב-i של החיצונית (LOOP j FROM 1 TO i) או קבועה (1 TO n → פשוט n²)? (3) מהו הצעד — i שגדל ב-i = i + i רץ log n ולא n. כשמסתבכים: Dry Run על n=3 ובודקים מול הנוסחה.

🎯 דגש למבחן

בשפות Assembly-Style יש רגיסטר נסתר — הוסיפו את ACC ל-Symbol Table. ב-NovaCal LOAD, ADD, SUB ו-SAVE כולם עובדים מול ACC (Accumulator) — רגיסטר עבודה יחיד שלא מופיע בקוד כשם משתנה. הטעות הנפוצה: לעקוב רק אחרי i ו-total ולהתבלבל. הפתרון: עמודת ACC בטבלה לצד המשתנים. ADD x אינו x += ... אלא ACC += x, והערך נכתב למשתנה רק ב-SAVE. שימו לב ל-LOAD i / ADD i / SAVE i — זה i = i * 2, לא i + 1.

// פרקים 4–7

שלוש שפות: Zenith, Kova, NovaCal

כל שפה בכנס תהיה שונה. המטרה: להכיר 3 סוגי Syntax שונים בתכלית — כדי שכל שפה חדשה תיראה מוכרת.

שפת Zenith — Syntax מילולי

Zenith Spec (עיקרי)

LET <name> = <value>     ; הגדרת משתנה
SET <name> TO <expr>    ; עדכון ערך
FOR <var> = s TO e ... END FOR  ; כולל e!
WHILE cond ... END WHILE
IF cond THEN ... ELSE ... END IF
FUNC f(p) ... RETURN v ... END FUNC
PRINT x
arr[i] / arr.SIZE
= (eq) / <> (neq) / MOD (%) / ^ (power)

שפת Kova — Syntax סמלי

Kova Spec (עיקרי)

var x : num          ; הגדרת משתנה
x := expr            ; השמה
? cond { }           ; if
? cond { } ~ { }     ; if/else (~ = else)
?? cond { }          ; elseif
@ var in s..e { }    ; for loop (inclusive!)
@@ cond { }          ; while loop
fn f(p:num)->num { return v; }
>> x                 ; הדפסה
|arr|                ; גודל מערך
== / != / && / || / !

שפת NovaCal — Assembly Style

NovaCal Spec (עיקרי)

STORE <val> IN <name>    ; x = val
COPY x TO y               ; y = x
SWAP x y                  ; swap
LOAD x   → ACC = x       ; load to accumulator
ADD x    → ACC += x
SUB x    → ACC -= x
SAVE x   → x = ACC
IFGT a b JUMP <label>    ; if a > b: goto label
GOTO <label>
EMIT x                    ; print(x)

// NovaCal Dry Run:
STORE 1 IN i       // i=1
STORE 0 IN total   // total=0
LOOP_START:
    IFGT i 5 JUMP LOOP_END    // i>5? jump
    LOAD total
    ADD i
    SAVE total     // total += i
    LOAD i
    ADD i
    SAVE i         // i = i+i = i*2 !!
GOTO LOOP_START
LOOP_END:
EMIT total

// Symbol Table:
// init: i=1, total=0
// iter 1: IFGT 1>5→F → total=0+1=1, i=1+1=2
// iter 2: IFGT 2>5→F → total=1+2=3, i=2+2=4
// iter 3: IFGT 4>5→F → total=3+4=7, i=4+4=8
// iter 4: IFGT 8>5→T → JUMP LOOP_END
// EMIT total → פלט: 7

הרחבה Dry Run על Kova: while loop ורקורסיה ›

// Kova — while loop
var a : num
var c : num
a := 5
c := 0
@@ a > 2 {
    c := c + a
    a := a - 1
}
>> c
// iter 1: a=5>2→T → c=0+5=5, a=4
// iter 2: a=4>2→T → c=5+4=9, a=3
// iter 3: a=3>2→T → c=9+3=12, a=2
// iter 4: a=2>2→F → stop
// פלט: 12

// Kova — רקורסיה (Fibonacci)
fn fib(n:num)->num {
    ?? n=0 { return 0; }
    ?? n=1 { return 1; }
    ~ { return fib(n-1)+fib(n-2); }
}
>> fib(5)
// עץ קריאות:
// fib(5) = fib(4)+fib(3) = 3+2 = 5
// פלט: 5

✏תרגול עצמי3 שאלות

שאלה 5.1 — Kova while

Kova — @@ x > 0 { x := x - 3 } עם x=10. מה ערך x כשהלולאה מסתיימת?

✓ תשובה: א) -2 — Symbol Table: x=10→7→4→1→-2. iter 4: x=1>0→T → x=1-3=-2. iter 5: -2>0→F → stop. ערך סיום: x=-2. ג!

שאלה 5.2 — NovaCal

NovaCal — STORE 5 IN x → LOAD x → SUB x → SAVE x → EMIT x. מה הפלט?

✓ תשובה: ב) 0 — STORE 5 IN x → x=5. LOAD x → ACC=5. SUB x → ACC=ACC-x=5-5=0. SAVE x → x=0. EMIT x → פלט: 0.

שאלה 5.3 — Kova Syntax

Kova — מה ההבדל בין @ לבין @@?

✓ תשובה: ב) — @ var in s..e { } = for loop (ספירה, inclusive!). @@ cond { } = while loop. זה בדיוק סוג הבלבול שקורה בכנס — לזכור את טבלת Pattern!

🎯 דגש למבחן

Tokenizer: אופרטור של שני תווים נקרא כיחידה אחת. הטוקנייזר תמיד מנסה קודם את ההתאמה הארוכה ביותר (Maximal Munch). לכן ב-Kova := הוא טוקן אחד (השמה) ולא : + =; == הוא השוואה ולא שתי השמות; ו-.. בטווח 1..5 אינו שתי נקודות. אותו כלל ב-&&, ||, !=, ->, >> ו-??. הנקודה למבחן: אותו סימן משנה משמעות לפי מה שצמוד אליו — ? הוא if אבל ?? הוא elseif, ו-> הוא גדול מ- אבל >> הוא הדפסה.

// פרק 5

Stack Frames: מעקב פונקציות ורקורסיה

כשפונקציה קוראת לפונקציה — נוצר Stack Frame. כל Frame מחזיק: שם הפונקציה, פרמטרים, משתנים מקומיים. בזמן Dry Run: ציר כל Frame כעמודה נפרדת.

// Zenith — פקטוריאל רקורסיבי
FUNC fact(n)
    IF n <= 1 THEN
        RETURN 1
    END IF
    RETURN n * fact(n-1)
END FUNC

PRINT fact(4)

// Call Stack:
// fact(4): 4>1 → RETURN 4 * fact(3)
//   fact(3): 3>1 → RETURN 3 * fact(2)
//     fact(2): 2>1 → RETURN 2 * fact(1)
//       fact(1): n<=1 → RETURN 1  ← BASE CASE

// Rewinding:
//       fact(1) = 1
//     fact(2) = 2*1 = 2
//   fact(3) = 3*2 = 6
// fact(4) = 4*6 = 24
// PRINT fact(4) → 24

! Recursive Dry Run — הטעות הנפוצה ›

מנסים לעקוב בסדר "מלמעלה למטה" ומאבדים את ה-Thread.
✅ נכון: בנה עץ קריאות → מלא ערכים מהעלים כלפי מעלה (Leaves First).
❌ שגוי: לנסות לעקוב שורה-שורה ב"קפיצות" בין frames.
כלל: כל call = node בעץ. מלא leaves תחילה, אחר כך חשב parents.

✏תרגול עצמי3 שאלות

שאלה 7.1 — רקורסיה

Zenith — FUNC f(x): IF x <= 1 THEN RETURN 1 END IF. RETURN x + f(x-1). מה f(3)?

✓ תשובה: א) 6 — f(3)=3+f(2)=3+(2+f(1))=3+2+1=6. עץ: f(3)→f(2)→f(1)=1. Rewinding: f(2)=2+1=3, f(3)=3+3=6.

שאלה 7.2 — Call Stack

מה עומק ה-Call Stack של fact(5) הרקורסיבי?

✓ תשובה: ג) 5 frames — fact(5)→fact(4)→fact(3)→fact(2)→fact(1) = 5 frames. כל קריאה = frame אחד ב-Call Stack. Base Case = fact(1) מחזיר 1.

שאלה 7.3 — Zenith Dry Run מלא

LET arr[6]
SET arr[0]=2  arr[1]=5  arr[2]=1
SET arr[3]=8  arr[4]=3  arr[5]=7

LET result = arr[0]
FOR i = 1 TO 5
    IF arr[i] MOD 2 = 0 THEN
        IF arr[i] > result THEN
            SET result TO arr[i]
        END IF
    END IF
END FOR
PRINT result

מה הפלט?

✓ תשובה: ד) 8 — arr=[2,5,1,8,3,7], result=arr[0]=2. i=1: 5 MOD 2=1≠0 → skip. i=2: 1 odd → skip. i=3: 8 MOD 2=0 → 8>2? YES → result=8. i=4: 3 odd. i=5: 7 odd. PRINT 8. הקוד מחזיר המספר הזוגי הגדול!

🎯 דגש למבחן

פריסת רקורסיה: יורדים עד הבסיס, ואז מציבים פיזית בחזרה. אל תנסו לפתור רקורסיה בראש. כותבים את שרשרת הירידה עד תנאי העצירה — f(4) = 4 * f(3), f(3) = 3 * f(2), f(2) = 2 * f(1), f(1) = 1 — ואז מציבים מלמטה למעלה: f(2)=2, f(3)=6, f(4)=24. כל שורה היא Stack Frame עם עותק משלה של הפרמטרים; מי שמדלג על ההצבה הפיזית מתבלבל בדיוק בשלב הזה. שתי מלכודות: קריאה כפולה (fib(n-1) + fib(n-2)) דורשת עץ ולא שרשרת, ופעולה אחרי הקריאה הרקורסיבית מתבצעת רק בדרך חזרה למעלה.

// אתגר מעשי

אתגר מעשי — שפה מומצאת: Lexer ו-Symbol Table

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

T2 · בסיסי250 נק'~20 דק'algorithmic

Tokenizer לשפה מומצאת (שלב 1/5)

השלב הראשון בהרצת שפה הוא פירוק לאסימונים. ממש tokenize(s) שמפרק ביטוי לרשימת אסימונים (kind, text): NUM (רצף ספרות), ID (אות ואז אותיות/ספרות), OP (אחד מ- + - * / =), LP עבור '(', RP עבור ')'. דלג על רווחים. על תו לא-חוקי — זרוק ValueError.

דוגמאות

tokenize('x = 3 + 4') → [('ID','x'),('OP','='),('NUM','3'),('OP','+'),('NUM','4')]

tokenize('foo1*(2)') → [('ID','foo1'),('OP','*'),('LP','('),('NUM','2'),('RP',')')]

הפתרון שלךהפתרון נשמר מקומית ומשותף עם עמוד „כתיבת קוד”.

פתרון-ייחוס Tokenizer לשפה מומצאת (שלב 1/5) ›

def tokenize(s: str) -> list[tuple[str, str]]:
    toks = []; i = 0; n = len(s)
    while i < n:
        c = s[i]
        if c == ' ':
            i += 1; continue
        if c.isdigit():
            j = i
            while j < n and s[j].isdigit(): j += 1
            toks.append(("NUM", s[i:j])); i = j
        elif c.isalpha():
            j = i
            while j < n and s[j].isalnum(): j += 1
            toks.append(("ID", s[i:j])); i = j
        elif c in "+-*/=": toks.append(("OP", c)); i += 1
        elif c == '(':     toks.append(("LP", c)); i += 1
        elif c == ')':     toks.append(("RP", c)); i += 1
        else: raise ValueError(f"bad char {c!r}")
    return toks

T3 · בינוני350 נק'~20 דק'algorithmic

Symbol Table — בדיקת הצהרות

אחרי הפירוק לאסימונים בונים טבלת סמלים. נתונה רשימת שורות; כל שורה היא "let NAME" (הצהרה) או "set NAME"/"get NAME" (שימוש). עבד לפי הסדר והחזר את השגיאה הראשונה: הצהרה חוזרת של שם קיים → "redeclare:NAME"; שימוש בשם שלא הוצהר → "undeclared:NAME". אם אין שגיאות → "ok".

דוגמאות

check_symbols(['let x','set x']) → 'ok'

check_symbols(['set x']) → 'undeclared:x'

check_symbols(['let x','let x']) → 'redeclare:x'

הפתרון שלךהפתרון נשמר מקומית ומשותף עם עמוד „כתיבת קוד”.

פתרון-ייחוס Symbol Table — בדיקת הצהרות ›

def check_symbols(lines: list[str]) -> str:
    declared = set()
    for ln in lines:
        op, name = ln.split()
        if op == 'let':
            if name in declared: return f"redeclare:{name}"
            declared.add(name)
        else:                                  # 'set'/'get' = שימוש
            if name not in declared: return f"undeclared:{name}"
    return "ok"

// סיכום

סיכום השיעור

✓מה למדנו בשיעור זה

5 שלבים: סקר מהיר → מיפוי Pattern → Trace דוגמה → Dry Run+Symbol Table → ניהול זמן
Pattern Recognition: 8 Building Blocks בכל שפה + טבלת operators
Symbol Table: כלי חובה לכל Dry Run. לולאות = עמודה נוספת לloop variable
שפת Zenith: LET/SET, FOR-END FOR (כולל!), FUNC-END FUNC, MOD, ^
שפת Kova: var, :=, @(for), @@(while), ?(if), fn, >>, |arr|
שפת NovaCal: STORE, LOAD, ADD, SUB, SAVE, IFGT, JUMP, EMIT
Stack Frames: frame לכל פונקציה, עץ קריאות לרקורסיה, leaves תחילה
ניהול זמן: 3 דקות max, סמן ועבור הלאה, חזור בסוף

🎯 השיעור הבא

שיעור 12 — Dry Run מתקדם
לפני שיעור 12: עשה Dry Run על כל 3 שפות — עוד 5 קטעי קוד כל שפה. כתוב Symbol Table על נייר — לא בראש. בנה עץ קריאות לfib(6) ולfact(5).

✏תרגול סיום — גאמא סגנון3 שאלות

גאמא סגנון א׳

Zenith — WHILE x > 0 עם x=0 מהתחלה: כמה פעמים רץ הגוף?

✓ תשובה: ג) 0 — בדיקת תנאי לפני גוף. 0>0=FALSE מיד → 0 iterations. WHILE/while תמיד בודק תנאי לפני הכניסה לגוף.

גאמא סגנון ב׳

Zenith — FUNC fact(5) רקורסיבי, מה ערך n כשמגיעים ל-Base Case?

✓ תשובה: ג) 1 — fact(5)→fact(4)→fact(3)→fact(2)→fact(1). n=1 → IF n<=1 THEN RETURN 1 (Base Case). עומק: 5 frames.

גאמא סגנון ג׳

מה ההבדל העיקרי בין Zenith לKova ב-for loop?

✓ תשובה: ד) — שתיהן inclusive: Zenith FOR i=1 TO 5 = i=1,2,3,4,5. Kova @ i in 1..5 = i=1,2,3,4,5. ViLang "upto" = exclusive (שונה!). תמיד בדוק בדוגמות המפרט.

שאלות תרגול ותשובות (10)

שאלה 1 · מה יודפס? (שפת Zenith — FOR כולל את הגבול העליון)

LET sum = 0
FOR i = 1 TO 10
    IF i MOD 2 = 0 THEN
        SET sum TO sum + i
    END IF
END FOR
PRINT sum

א. 25
ב. 30
ג. 20
ד. 55

תשובה: ב

הזוגיים 2+4+6+8+10 = 30. שימו לב ש-TO 10 כולל את 10.

שאלה 2 · מה יודפס? (Zenith — לולאה פנימית התלויה ב-i)

SET count TO 0
LOOP i FROM 1 TO 3
    LOOP j FROM 1 TO i
        ADD count BY 1
    ENDLOOP
ENDLOOP
OUTPUT count

א. 3
ב. 6
ג. 9
ד. 12

תשובה: ב

1+2+3 = 6 — הפנימית תלויה ב-i, ולכן n(n+1)/2 ולא n².

שאלה 3 · מה יודפס? (NovaCal — עקבו אחרי ה-ACC)

STORE 1 IN i
STORE 0 IN total
LOOP_START:
    IFGT i 5 JUMP LOOP_END
    LOAD total
    ADD i
    SAVE total
    LOAD i
    ADD i
    SAVE i
GOTO LOOP_START
LOOP_END:
EMIT total

א. 7
ב. 15
ג. 8
ד. 5

תשובה: א

i מוכפל בכל סיבוב (1,2,4,8): total = 1+2+4 = 7, ואז 8>5 קופץ החוצה.

שאלה 4 · מה עושה רצף הפקודות הזה ב-NovaCal?

LOAD x
ADD x
SAVE x

א. x = x + 1
ב. x = x * 2
ג. ACC = 0
ד. מחליף בין x ל-ACC

תשובה: ב

ACC נטען ב-x ואז מוסיפים לו שוב x — כלומר x = x + x.

שאלה 5 · מה יודפס? (Kova — @ הוא לולאת for וטווח a..b הוא inclusive)

var t : num
t := 0
@ i in 1..4 {
    t := t + i * i
}
>> t

א. 14
ב. 30
ג. 20
ד. 10

תשובה: ב

1+4+9+16 = 30 — הטווח כולל את 4.

שאלה 6 · לכמה טוקנים מפרק ה-Tokenizer את השורה הבאה ב-Kova?

x := y == 3

א. 4 טוקנים: x , := , y , == , 3 — כלומר 5
ב. 5 טוקנים: x, :=, y, ==, 3
ג. 7 טוקנים: כל תו בנפרד
ד. 3 טוקנים

תשובה: ב

Maximal Munch — := ו-== נקראים כיחידה אחת כל אחד, ולא כשני סימנים נפרדים.

שאלה 7 · מה מחזירה הקריאה f(4)?

FUNC f(n)
    IF n = 1 THEN
        RETURN 1
    END IF
    RETURN n * f(n - 1)
END FUNC

PRINT f(4)

א. 10
ב. 16
ג. 24
ד. 4

תשובה: ג

פריסה והצבה חזרה: f(1)=1 → f(2)=2 → f(3)=6 → f(4)=24.

שאלה 8 · כמה קריאות (frames) ייפתחו בסך הכול עבור g(4), כולל הקריאה הראשונה?

FUNC g(n)
    IF n <= 1 THEN
        RETURN n
    END IF
    RETURN g(n - 1) + g(n - 2)
END FUNC

א. 4
ב. 5
ג. 7
ד. 9

תשובה: ד

קריאה כפולה בונה עץ: g(4)→g(3),g(2)... בסך הכול 9 קריאות — לכן Memoization חיונית.

שאלה 9 · מה יודפס? (שימו לב לתנאי העצירה של הלולאה)

LET x = 10
WHILE x > 0
    SET x TO x - 3
END WHILE
PRINT x

א. 0
ב. 1
ג. -2
ד. 4

תשובה: ג

10→7→4→1→-2; בערך 1 התנאי עדיין מתקיים, ולכן הלולאה מבצעת סיבוב נוסף.

שאלה 10 · מה יודפס? (Kova — ~ הוא else)

var n : num
n := 7
? n MOD 2 == 0 {
    >> n / 2
} ~ {
    >> n * 3 + 1
}

א. 3
ב. 22
ג. 7
ד. 14

תשובה: ב

7 אי-זוגי, לכן מתבצע ענף ה-else: 7*3+1 = 22.

← שיעור קודם שיעור הבא →