סדנת פרזנטציה — סימולציית ראיון מקצועי

סימולציות מיון · 5–6 שעות

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

// סקירה

סדנת פרזנטציה — סימולציית ראיון מקצועי

הראיון המקצועי בגאמא לא בודק רק "מה ידעת" — הוא בודק "איך אתה חושב". הסוד: הראיון הוא שיחה, לא מבחן. Authenticity + Technical Depth + Self-Awareness = הרשמה.

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

הצגת פרויקט — מבנה 10 דקות: Problem→Solution→Tech→Demo→Code
הגנה על החלטות — REASON + TRADEOFF + ALTERNATIVE
Live Coding — 5 שלבים: הבן→דבר→Brute Force→Test→Optimize
STAR Method — תשובות התנהגותיות קונקרטיות ומשכנעות
שאלות טכניות גאמא — Process/Thread, Virtual Memory, TCP/UDP, Buffer Overflow
Anti-Patterns — מה לא לעשות: שתיקה, 'לא יודע' ועצירה, הגזמה
שפת גוף — קשר עין, ישיבה זקופה, קצב מאוזן, הפסקות מכוונות
Post-Interview Reflection — ניתוח תוך שעה לשיפור לסבב הבא

🎯 קשר למיוני גאמא

שיעור זה מכין ישירות לראיון: הצגת פרויקט שבנית · שאלות Live Coding · שאלות "למה בחרת X?" · שאלות ידע על Process/Memory/TCP/Security

// פרק 1

הצגת פרויקט: מבנה 10 הדקות

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

זמן	חלק	תוכן ומה לומר
0:00–1:30	PROBLEM	"שמתי לב ש-X קשה / לוקח זמן / לא קיים — ולכן בניתי..."
1:30–3:00	SOLUTION	"בניתי [שם] שמאפשר ל-[קהל] ל-[יכולת]. הוא עושה זאת על ידי..."
3:00–5:00	TECH	ארכיטקטורה + כלים. "בחרתי X כי Y. אם Z שונה, הייתי בוחר W"
5:00–7:30	DEMO	Feature אחד מרכזי + נקודה טכנית מעניינת תוך כדי
7:30–9:00	CODE	הקטע הכי מאתגר. "פתרתי X על ידי Y. שקלתי Z אבל בחרתי X כי..."
9:00–10:00	NEXT + שאלות	"אם היה לי יותר זמן, הייתי מוסיף X. הלקח הגדול: Y. שאלות?"

🧑‍💼 בוחןספר לי על הפרויקט שלך — 10 דקות

בחרתי לבנות Port Scanner כי בCTF תמיד הפעלתי nmap ולא הבנתי מה קורה מתחת לכיסוי. רציתי לבנות מאפס ולהוכיח שאני מבין TCP/IP. בניתי CLI ב-Python שסורק פורטים, מזהה שירותים לפי Banner Grabbing, ומייצר דוח. ה-Thread Pool של 50 Workers שיפר מ-20 שניות ל-2 שניות. החלק הכי מעניין: טיפול ב-Race Condition ב-Result Collection עם threading.Lock().

הרחבה הגנה על החלטות — REASON + TRADEOFF + ALTERNATIVE ›

🧑‍💼למה בחרת Python ולא C++?

בחרתי Python כי הפרויקט הוא Scripting tool ולא Real-Time System — אז Overhead ה-Performance לא קריטי. Python נותן socket ו-threading ב-stdlib ללא dependencies. אם הייתי צריך לסרוק מיליוני hosts, הייתי בוחר Go — מהיר יותר עם Goroutines.

🧑‍💼הקוד שלך לא כולל Unit Tests. למה?

צודק — זו חולשה שאני מודע אליה. הזמן הלך לגרום ל-Logic לעבוד. אם הייתי עושה שוב: הייתי מתחיל עם pytest ו-2-3 tests בסיסיים. בVersion הבא אני מתכנן להוסיף.

הכלל: תמיד REASON (למה בחרת) + TRADEOFF (החיסרון) + ALTERNATIVE (מה בגרסה אחרת). זה מראה שחשבת, לא סתם בחרת.

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

שאלה 1.1 — מבנה הצגה

הבוחן נותן לך 10 דקות להציג פרויקט. מה עדיף לפתוח איתו?

✓ תשובה: א) הבעיה — PROBLEM קודם! כי בלי Context לבעיה, הפתרון לא מובן. "בניתי Port Scanner" לבד = לא מרשים. "לא הבנתי מה nmap עושה, אז בניתי מאפס" = מעניין, מסביר Motivation, ומראה Curiosity. הבוחן רוצה להבין למה בנית, לא רק מה בנית.

שאלה 1.2 — הגנת החלטות

הבוחן שואל: "למה בחרת SQLite ולא PostgreSQL?" מה התשובה הטובה ביותר?

✓ תשובה: א) — מבנה REASON+TRADEOFF+ALTERNATIVE: REASON = "מתאים לSingle-User". TRADEOFF = "הכרה בחיסרון". ALTERNATIVE = "בתנאים אחרים הייתי בוחר PostgreSQL". זה מראה שחשבת על הבחירה ולא סתם לקחת מה שידעת. תשובות א' וג' חושפות שלא חשבת, ד' לא רלוונטי טכנית.

שאלה 1.3 — Anti-Pattern בהצגה

המועמד אומר: "בניתי מערכת מאוד מורכבת עם AI ו-Microservices ו-Kubernetes." אחר כך שואלים אותו "איך ה-Load Balancer עובד?" והוא לא יודע לענות. מה הבעיה?

✓ תשובה: ב) הגזמה — כלל הזהב: לא מצהירים על דבר שלא מסוגלים להסביר לעומק. הבוחן ימשוך בכל "Kubernetes" ו"AI" שאמרת וישאל עליהם. פחות Feature, יותר הבנה: להסביר 3 שורות קוד לעומק > 30 שורות שטחי. Authenticity מנצחת תמיד.

// פרק 2

Live Coding + STAR Method

Live Coding הוא החלק הכי מפחיד. הפתרון: לא כותבים קוד מושלם בלחץ — חושבים בקול, מסבירים תוך כדי, ומגיעים לפתרון עובד.

שיטת Live Coding — 5 שלבים

שלב	מה עושים	מה אומרים
1. הבן	הבהר לפני שמתחיל	"Input הוא X? יכול להיות None? Output = List של Tuples?"
2. דבר	חשוב בקול — לא שתיקה	"אני חושב ל-Loop על המערך, לכל Element אבדוק..."
3. Brute Force	פתרון פשוט ועובד קודם	"אתחיל עם O(n²) פשוט, ואז נשפר"
4. Test	הרץ ידנית על דוגמה	"find_pairs([1,2,3,4], 5) → [(1,4),(2,3)] ✓"
5. Optimize	שפר רק אחרי שעובד	"הפתרון הנוכחי O(n²) — אפשר O(n) עם HashSet"

# ─── Live Coding: find_pairs ─────────────────────────────
# שאלה: מצא זוגות שסכומם = target

# Brute Force O(n²) — מתחילים כאן:
def find_pairs(nums, target):
    pairs = []
    for i in range(len(nums)):
        for j in range(i+1, len(nums)):
            if nums[i] + nums[j] == target:
                pairs.append((nums[i], nums[j]))
    return pairs
# test: find_pairs([1,2,3,4], 5) → [(1,4),(2,3)] ✓

# Optimized O(n) — HashSet:
def find_pairs_fast(nums, target):
    seen = set()
    pairs = []
    for num in nums:
        complement = target - num
        if complement in seen:
            pairs.append((complement, num))
        seen.add(num)
    return pairs

# ─── Edge Cases חשוב לציין: ──────────────────────────────
# find_pairs([2,2], 4)         → [(2,2)] ✓ (כפולים)
# find_pairs([], 5)            → [] ✓ (רשימה ריקה)
# find_pairs([1,2,3], 10)      → [] ✓ (אין זוג)
# find_pairs([1,-1,2,-2], 0)   → [(-1,1),(-2,2)] ✓ (שליליים)

STAR Method — שאלות התנהגותיות

מבנה תשובת STAR

Situation: "בפרויקט X, שהיה Y, הייתה לנו בעיה ש..."

Task: "הייתי אחראי על / היה צריך / תפקידי היה..."

Action: "פתחתי / בדקתי / שאלתי / שיניתי גישה כי..."

Result: "בסוף הצלחתי / למדתי / קיבלתי פידבק ש..."

🧑‍💼ספר על פעם שנתקעת בבעיה טכנית ולא ידעת לפתור

[S] בבניית Port Scanner, Thread Pool לא עבד — חלק מהPorts לא סרקו. [T] הייתי צריך להבין למה Workers מסוימים לא מסיימים. [A] הוספתי logging לכל Thread — ראיתי שSocket connections תקועים indefinitely. מצאתי שלא הגדרתי timeout. הוספתי socket.settimeout(1.0). [R] הBug תוקן. הלקח: Timeout הוא לא Optional בNetworking.

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

שאלה 2.1 — Live Coding Mindset

בזמן Live Coding נתקעת 3 דקות בשתיקה מוחלטת. מה הצעד הנכון?

✓ תשובה: ב) חשוב בקול — שתיקה = הכי גרוע ב-Live Coding. הבוחן לא יכול לדעת אם אתה חושב או מאבד כיוון. חשיבה בקול: (1) מראה Process חשיבה. (2) מאפשר לבוחן לכוון אם הולך בכיוון שגוי. (3) לפעמים הסבר בקול מגלה את הפתרון. "אני לא בטוח אבל אנסה X" > שתיקה.

שאלה 2.2 — STAR Method

הבוחן שואל: "איך אתה לומד טכנולוגיה חדשה?" מה התשובה הטובה ביותר?

✓ תשובה: א) STAR קונקרטי — תשובה ב' = טענה ריקה בלי הוכחה. תשובה ג' = לא מראה מתודולוגיה. תשובה א' = STAR עם דוגמה ספציפית ושיטה קונקרטית (README→Example→Implement). הבוחן רוצה לראות שיש לך Process, לא שאתה "לומד טוב". ספציפי תמיד עדיף על כללי.

שאלה 2.3 — Dry Run: find_pairs

הרצת find_pairs_fast([3, 1, 4, 1, 5], 6) עם HashSet. מה התוצאה?

✓ תשובה: ד) [(1,5)] — מעקב: seen={}, pairs=[]. num=3: 6-3=3 not in {} → seen={3}. num=1: 6-1=5 not in {3} → seen={3,1}. num=4: 6-4=2 not in {3,1} → seen={3,1,4}. num=1: 6-1=5 not in {3,1,4} → seen={3,1,4}. num=5: 6-5=1 in {3,1,4} → append (1,5). Result = [(1,5)]. שים לב: הזוג (1,5) נמצא אבל (3,3) לא — כי 3 מופיע פעם אחת.

// פרק 3

שאלות טכניות נפוצות בראיון גאמא

הנה השאלות שחוזרות על עצמן — עם תשובות מודל שמראות Depth ולא רק Knowledge.

OSמה ההבדל בין Process לThread? מתי תבחר כל אחד?

Process = תוכנה עצמאית עם Memory Space משלה. Thread = unit הרצה בתוך Process — חולק Memory. Thread קל ומהיר ליצירה, תקשורת מהירה — אבל Race Condition סכנה. Process בטוח יותר — Crash לא מפיל אחרים — אבל IPC כבד יותר. אבחר Thread לI/O-bound (Network, File). אבחר Process לCPU-bound (Image Processing) לניצול Multi-Core.

OSמה זה Virtual Memory ולמה זה קיים?

Virtual Memory נותן לכל Process אשליה שיש לו את כל הזיכרון לעצמו. ה-OS ממפה Virtual Addresses לPhysical דרך Page Table. למה? (1) Isolation: Process A לא יכול לגשת לזיכרון B — Security. (2) Over-commitment: 10 תוכניות רצות גם אם דורשות יותר RAM. (3) Simplicity: כל תוכנה מניחה שמתחילה מ-0x0.

NETTCP vs UDP: מה ההבדל ומתי משתמשים?

TCP: Connection-Oriented, Reliable, Ordered. כל Packet מאושר. UDP: Connectionless, Unreliable, מהיר, Low Overhead. TCP: HTTP/S, SSH, Email — כשנתון לא יכול ללכת לאיבוד. UDP: DNS (שאלות קצרות, Retry מהיר), Video Streaming (frame מאוחר = דלג עליו), Gaming (Lag גרוע מPacket Loss).

SECמה זה Buffer Overflow ואיך מגנים עליו?

Buffer Overflow: כתיבה מחוץ לגבולות Buffer ב-Stack/Heap, מאפשר לדרוס Return Address ולהריץ Shellcode. הגנות: (1) Stack Canary — ערך סודי לפני Return Address. (2) ASLR — כתובות אקראיות. (3) NX/DEP — Stack לא Executable. (4) Safe Functions — fgets() במקום gets(). (5) Compiler Flags — -fstack-protector.

OOPהסבר Polymorphism ותן דוגמה בקוד

Polymorphism = אותה Interface, התנהגות שונה לפי Type. מאפשר קוד גנרי: for shape in shapes: shape.draw() — Circle.draw() מציירת עיגול, Square.draw() ריבוע. הקוד לא צריך לדעת את ה-Type בפועל. זה הבסיס לDesign Patterns כמו Strategy ו-Observer.

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

שאלה 3.1 — Process vs Thread

יש לך Web Server שמטפל ב-1000 Requests בו-זמנית, כל Request עושה I/O לDB. מה עדיף — Thread Pool או Process Pool?

✓ תשובה: ג) Thread Pool — I/O-bound = Thread Pool. הסיבות: (1) Threads קלים ליצירה × 1000. (2) חולקים Memory — 1000 Processes = ~1000×overhead. (3) ב-I/O, Python משחרר GIL → Threads יכולים לרוץ מקביל. Process Pool עדיף לCPU-bound (image processing, crypto). ד) נכון שGIL קיים, אבל I/O משחרר אותו!

שאלה 3.2 — Buffer Overflow

checksec מראה: No Canary, NX enabled, No PIE. מה אפשרי?

✓ תשובה: ד) — No Canary: Buffer Overflow ל-Return Address בלי הגנה. No PIE: כתובות libc/binary קבועות → לא צריך Leak. NX: Stack לא Executable → Shellcode ב-Stack לא עובד. Combo = ret2libc (קפוץ ל-system("/bin/sh")) או ROP Chain. ד) שגוי — NX בדיוק מונע Shellcode ב-Stack.

שאלה 3.3 — DNS + TCP Flow

מה קורה ב-Network Level כשמקלידים "github.com" בדפדפן? (4 שלבים עיקריים)

✓ תשובה: ד) — הסדר: (1) DNS: "מה ה-IP של github.com?" → 140.82.X.X. (2) TCP 3-Way Handshake: SYN → SYN-ACK → ACK. (3) TLS Handshake: Certificate exchange + Session Key (AES). (4) HTTP GET + Response → HTML. שים לב: DNS מגיע ראשון (אי אפשר לחבר בלי IP). TCP קודם לTLS (TLS רץ על TCP).

// פרק 4

Anti-Patterns + סיכום

הטעויות הבאות מכשילות מועמדים טובים — לא בגלל חוסר ידע, אלא בגלל Behavior שגוי. כל Anti-Pattern מגיע עם Alternative.

Anti-Pattern ❌	תגובה נכונה ✅
שתיקה ממושכת בLive Coding	חשוב בקול: "אני חושב על HashSet כי צריך O(1) lookup..."
"לא יודע" ועצירה מוחלטת	"לא יודע בוודאות — אבל הייתי מנחש ש... כי... אתה יכול לכוון?"
הגזמה: "AI + Microservices + Kubernetes"	כנות: "CLI Tool עם Threads — הבנתי Sockets לעומק"
קוד עובד בDemo, הסבר מעורפל	פחות Feature, יותר הבנה: הסבר 3 שורות לעומק
לא לשאול הבהרה לפני Live Coding	"Input הוא List של ints? יכול להיות None? מחזיר Tuples?"
"לא הוספתי Tests כי לקח זמן"	"Tests לא הספקתי — Scope Creep. בפרויקט הבא מתחיל מ-Happy Path test"

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

הצגת פרויקט: Problem→Solution→Tech→Demo→Code. 10 דקות, סיפור אחד ברור
הגנת החלטות: REASON + TRADEOFF + ALTERNATIVE. לא "כי ידעתי" — כי "זה התאים לRequirements"
Live Coding: הבן → דבר בקול → Brute Force → Test → Optimize. לא שתיקה!
STAR Method: Situation → Task → Action → Result. תשובות קונקרטיות, לא מופשטות
Process vs Thread: I/O-bound → Thread. CPU-bound → Process. ב-Python: GIL משחרר ב-I/O
Virtual Memory: Isolation + Over-commitment + Simplicity. Page Table: VA → PA
TCP vs UDP: Reliable/Ordered vs Fast/Unreliable. HTTP→TCP, DNS→UDP, Streaming→UDP
Buffer Overflow: Stack Canary, ASLR, NX/DEP, Safe Functions, Compiler Flags
Anti-Patterns: אל תשתוק, אל תגיד "לא יודע" ותעצור, אל תגזים, שאל הבהרה תמיד
Post-Interview: Reflection תוך שעה. מה עבד? מה לא? Rating לפי קטגוריה. מה ללמוד?

🏆 הכנה ליום הראיון

□ הכן 3 Stories בSTAR format: Bug שמצאת, אתגר שפתרת, משהו שלמדת
□ הכן שאלות לבוחן: "מה הטכנולוגיות שהיחידה משתמשת?", "יום טיפוסי ביחידה?"
□ לילה לפני: Review קצר של הפרויקט — לא למידה חדשה
□ הגע 15 דקות לפני — לא 5
□ תרגל Live Coding: Fibonacci iterative, Find Pairs, Palindrome check

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

גאמא סגנון א׳ — Live Coding: Fibonacci

הבוחן מבקש: "כתוב Fibonacci iterative". מה קוד Python נכון ויעיל?

✓ תשובה: ד) Iterative עם שני משתנים — הפתרון הנכון: def fib(n): a,b=0,1 \n for _ in range(n): a,b=b,a+b \n return a. זמן O(n), זיכרון O(1). Recursive א') = O(2^n) — איטי מאוד. ד') = O(n) זמן אבל O(n) זיכרון. בוחן מחפש Iterative (לא Recursive) + מינימל זיכרון. שני משתנים = הפתרון הקלאסי.

גאמא סגנון ב׳ — STAR בפועל

הבוחן: "מה תעשה אם נדרש ממך לעבוד עם טכנולוגיה שמעולם לא ראית?" מה התשובה הכי טובה?

✓ תשובה: ב) דוגמה ספציפית + שיטה — זוהי תשובת STAR מושלמת: [S] "בסדנה", [A] "dir() → help() → Example → ממשתי", [R] "30 דקות". תשובות א'-ג' = טענות ריקות ללא הוכחה. תשובה ד' = הוכחה + שיטה קונקרטית. הבוחן רוצה Evidence, לא Claims.

גאמא סגנון ג׳ — שאלת ידע + Tradeoff

הבוחן: "מתי HTTP/2 עדיף על HTTP/1.1?" מה תשובה שמראה Depth?

✓ תשובה: ג) — זוהי תשובה עם Depth: מסבירה מדוע (Multiplexing), מתי (resources קטנים), ומתי פחות רלוונטי (API requests גדולות). ב') = כללי ולא מדויק (לא "תמיד"). ג') = מוטעה. ד') = לא יודע + עצירה (Anti-Pattern). אפשר לומר "לא מכיר לעומק" אם אמת — אבל לנסות להסיק מה שיודעים על HTTP.

// סימולציית מיון

אתגר מעשי — סימולציית ראיון — Live Coding

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

T5 · שיא800 נק'~15 דק'algorithmic⏱ בונוס-זמן

Live-Coding — מיזוג מרווחים

שאלת ראיון קלאסית. נתונה רשימת מרווחים [start, end]; מזג את כל החופפים והחזר רשימה ממוינת של מרווחים לא-חופפים. מרווחים שנוגעים (למשל [1,4],[4,5]) נחשבים חופפים.

דוגמאות

merge_intervals([[1,3],[2,6],[8,10],[15,18]]) → [[1,6],[8,10],[15,18]]

merge_intervals([[1,4],[4,5]]) → [[1,5]]

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

פתרון-ייחוס Live-Coding — מיזוג מרווחים ›

def merge_intervals(intervals: list) -> list:
    if not intervals: return []
    it = sorted(intervals)
    res = [list(it[0])]
    for s, e in it[1:]:
        if s <= res[-1][1]: res[-1][1] = max(res[-1][1], e)  # חופף -> מיזוג
        else: res.append([s, e])
    return res

T4 · מתקדם550 נק'~12 דק'algorithmic⏱ בונוס-זמן

Live-Coding — סיבוב מטריצה 90°

שאלת ראיון נפוצה. נתונה מטריצה ריבועית n×n; החזר אותה מסובבת 90 מעלות עם כיוון השעון. (רמז: התא [i][j] בתוצאה מגיע מהתא [n-1-j][i] במקור.)

דוגמאות

rotate90([[1,2],[3,4]]) → [[3,1],[4,2]]

rotate90([[1,2,3],[4,5,6],[7,8,9]]) → [[7,4,1],[8,5,2],[9,6,3]]

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

פתרון-ייחוס Live-Coding — סיבוב מטריצה 90° ›

def rotate90(m: list) -> list:
    n = len(m)
    return [[m[n-1-j][i] for j in range(n)] for i in range(n)]  # 90° עם כיוון השעון

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

שאלה 1.1 — מבנה הצגה · הבוחן נותן לך 10 דקות להציג פרויקט. מה עדיף לפתוח איתו?

א. פתח עם הבעיה שפתרת (“שמתי לב ש-X”) — זה נותן Context לכל השאר
ב. פתח בהצגת רשימה של כל הטכנולוגיות והכלים שבהם השתמשת בפרויקט
ג. פתח בהצגת הקוד עצמו באופן ישיר, שהרי הבוחן רוצה לראות קוד
ד. פתח מיד עם Demo חי של המערכת כדי לרשום את הבוחן מהרגע הראשון

תשובה: א

✓ תשובה: א) הבעיה — PROBLEM קודם! כי בלי Context לבעיה, הפתרון לא מובן. "בניתי Port Scanner" לבד = לא מרשים. "לא הבנתי מה nmap עושה, אז בניתי מאפס" = מעניין, מסביר Motivation, ומראה Curiosity. הבוחן רוצה להבין למה בנית, לא רק מה בנית.

שאלה 1.2 — הגנת החלטות · הבוחן שואל: "למה בחרת SQLite ולא PostgreSQL?" מה התשובה הטובה ביותר?

א. “SQLite מתאים לפרויקט חד-משתמש; ל-Multi-User עוברים ל-PostgreSQL”
ב. “כי SQLite הוא פשוט הרבה יותר קל ומהיר ללמוד מאשר PostgreSQL”
ג. “כי זו בדיוק מערכת בסיס הנתונים שהראו והדגימו לנו בקורס”
ד. “כי PostgreSQL הוא פשוט יקר מדי עבור פרויקט אישי בהיקף קטן”

תשובה: א

✓ תשובה: א) — מבנה REASON+TRADEOFF+ALTERNATIVE: REASON = "מתאים לSingle-User". TRADEOFF = "הכרה בחיסרון". ALTERNATIVE = "בתנאים אחרים הייתי בוחר PostgreSQL". זה מראה שחשבת על הבחירה ולא סתם לקחת מה שידעת. תשובות א' וג' חושפות שלא חשבת, ד' לא רלוונטי טכנית.

שאלה 1.3 — Anti-Pattern בהצגה · המועמד אומר: "בניתי מערכת מאוד מורכבת עם AI ו-Microservices ו-Kubernetes." אחר כך שואלים אותו "איך ה-Load Balancer עובד?" והוא לא יודע לענות. מה הבעיה?

# ─── Live Coding: find_pairs ─────────────────────────────
# שאלה: מצא זוגות שסכומם = target

# Brute Force O(n²) — מתחילים כאן:
def find_pairs(nums, target):
    pairs = []
    for i in range(len(nums)):
        for j in range(i+1, len(nums)):
            if nums[i] + nums[j] == target:
                pairs.append((nums[i], nums[j]))
    return pairs
# test: find_pairs([1,2,3,4], 5) → [(1,4),(2,3)] ✓

# Optimized O(n) — HashSet:
def find_pairs_fast(nums, target):
    seen = set()
    pairs = []
    for num in nums:
        complement = target - num
        if complement in seen:
            pairs.append((complement, num))
        seen.add(num)
    return pairs

# ─── Edge Cases חשוב לציין: ──────────────────────────────
# find_pairs([2,2], 4)         → [(2,2)] ✓ (כפולים)
# find_pairs([], 5)            → [] ✓ (רשימה ריקה)
# find_pairs([1,2,3], 10)      → [] ✓ (אין זוג)
# find_pairs([1,-1,2,-2], 0)   → [(-1,1),(-2,2)] ✓ (שליליים)

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

תשובה: ב

✓ תשובה: ב) הגזמה — כלל הזהב: לא מצהירים על דבר שלא מסוגלים להסביר לעומק. הבוחן ימשוך בכל "Kubernetes" ו"AI" שאמרת וישאל עליהם. פחות Feature, יותר הבנה: להסביר 3 שורות קוד לעומק > 30 שורות שטחי. Authenticity מנצחת תמיד.

שאלה 2.1 — Live Coding Mindset · בזמן Live Coding נתקעת 3 דקות בשתיקה מוחלטת. מה הצעד הנכון?

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

תשובה: ב

✓ תשובה: ב) חשוב בקול — שתיקה = הכי גרוע ב-Live Coding. הבוחן לא יכול לדעת אם אתה חושב או מאבד כיוון. חשיבה בקול: (1) מראה Process חשיבה. (2) מאפשר לבוחן לכוון אם הולך בכיוון שגוי. (3) לפעמים הסבר בקול מגלה את הפתרון. "אני לא בטוח אבל אנסה X" > שתיקה.

שאלה 2.2 — STAR Method · הבוחן שואל: "איך אתה לומד טכנולוגיה חדשה?" מה התשובה הטובה ביותר?

א. “כשלמדתי requests התחלתי מ-README, הרצתי Example, ומימשתי בחצי שעה”
ב. “אני לומד טכנולוגיות חדשות בצורה מאוד טובה ובמהירות גבוהה מאוד”
ג. “אני בדרך כלל צופה בסרטוני Tutorials ב-YouTube עד שאני מבין”
ד. “זה תלוי מאוד בטכנולוגיה הספציפית שאותה אני צריך ללמוד כרגע”

תשובה: א

✓ תשובה: א) STAR קונקרטי — תשובה ב' = טענה ריקה בלי הוכחה. תשובה ג' = לא מראה מתודולוגיה. תשובה א' = STAR עם דוגמה ספציפית ושיטה קונקרטית (README→Example→Implement). הבוחן רוצה לראות שיש לך Process, לא שאתה "לומד טוב". ספציפי תמיד עדיף על כללי.

שאלה 2.3 — Dry Run: find_pairs · הרצת find_pairs_fast([3, 1, 4, 1, 5], 6) עם HashSet. מה התוצאה?

find_pairs_fast([3, 1, 4, 1, 5], 6)

א. [(3,3), (1,5)] — גם 3 משלים את עצמו ל-6 וגם 1 משלים את המספר 5
ב. [(1,5), (1,5)] — הזוג נספר פעמיים כי הערך 1 מופיע פעמיים ברשימה
ג. [(1,5), (3,3)] — שני זוגות, בסדר הפוך מסדר הופעתם ברשימה
ד. [(1,5)] — רק זוג אחד: 5 משלים ל-1 שכבר ב-seen; (3,3) כלל לא נוצר

תשובה: ד

✓ תשובה: ד) [(1,5)] — מעקב: seen={}, pairs=[]. num=3: 6-3=3 not in {} → seen={3}. num=1: 6-1=5 not in {3} → seen={3,1}. num=4: 6-4=2 not in {3,1} → seen={3,1,4}. num=1: 6-1=5 not in {3,1,4} → seen={3,1,4}. num=5: 6-5=1 in {3,1,4} → append (1,5). Result = [(1,5)]. שים לב: הזוג (1,5) נמצא אבל (3,3) לא — כי 3 מופיע פעם אחת.

שאלה 3.1 — Process vs Thread · יש לך Web Server שמטפל ב-1000 Requests בו-זמנית, כל Request עושה I/O לDB. מה עדיף — Thread Pool או Process Pool?

א. Process Pool, מכיוון שה-GIL של Python מונע מ-Threads לרוץ במקביל
ב. Process Pool, מכיוון שהוא נחשב לבטוח ויציב יותר בעומסים גבוהים
ג. Thread Pool — משימות I/O-bound; ה-Threads קלים וה-I/O משחרר את ה-GIL
ד. אין שום הבדל מעשי בין שתי הגישות, והבחירה ביניהן היא שרירותית

תשובה: ג

✓ תשובה: ג) Thread Pool — I/O-bound = Thread Pool. הסיבות: (1) Threads קלים ליצירה × 1000. (2) חולקים Memory — 1000 Processes = ~1000×overhead. (3) ב-I/O, Python משחרר GIL → Threads יכולים לרוץ מקביל. Process Pool עדיף לCPU-bound (image processing, crypto). ד) נכון שGIL קיים, אבל I/O משחרר אותו!

שאלה 3.2 — Buffer Overflow · checksec מראה: No Canary, NX enabled, No PIE. מה אפשרי?

א. ה-Binary מוגן לחלוטין, שכן ה-NX שהופעל בו מונע כל ניצול אפשרי
ב. Shellcode על ה-Stack אפשרי, שהרי אין Canary שיזהה את הדריסה
ג. קיים רק Stack Overflow, אך לא ניתן לנצל אותו בהיעדר ה-Canary
ד. Overflow אפשרי (אין Canary) וכתובות קבועות (אין PIE) → ROP/ret2libc

תשובה: ד

✓ תשובה: ד) — No Canary: Buffer Overflow ל-Return Address בלי הגנה. No PIE: כתובות libc/binary קבועות → לא צריך Leak. NX: Stack לא Executable → Shellcode ב-Stack לא עובד. Combo = ret2libc (קפוץ ל-system("/bin/sh")) או ROP Chain. ד) שגוי — NX בדיוק מונע Shellcode ב-Stack.

שאלה 3.3 — DNS + TCP Flow · מה קורה ב-Network Level כשמקלידים "github.com" בדפדפן? (4 שלבים עיקריים)

א. HTTP GET → TCP Connect → DNS Lookup → TLS Handshake, בסדר הזה
ב. UDP Connect → DNS Lookup → HTTP Request → HTML Render בדפדפן
ג. ARP Request → DNS Lookup → TCP Connect → UDP Data, בסדר הזה
ד. DNS Lookup → TCP 3-Way Handshake → TLS Handshake → HTTP GET Request

תשובה: ד

✓ תשובה: ד) — הסדר: (1) DNS: "מה ה-IP של github.com?" → 140.82.X.X. (2) TCP 3-Way Handshake: SYN → SYN-ACK → ACK. (3) TLS Handshake: Certificate exchange + Session Key (AES). (4) HTTP GET + Response → HTML. שים לב: DNS מגיע ראשון (אי אפשר לחבר בלי IP). TCP קודם לTLS (TLS רץ על TCP).

גאמא סגנון א׳ — Live Coding: Fibonacci · הבוחן מבקש: "כתוב Fibonacci iterative". מה קוד Python נכון ויעיל?

א. def fib(n): return fib(n-1)+fib(n-2) — רקורסיה כפולה ויקרה מאוד
ב. def fib(n): lst=[0,1]; append בלולאה; return lst[n] — O(n) זיכרון
ג. return sum(range(n)) — סכימה פשוטה של כל המספרים מאפס ועד n
ד. a,b=0,1; לולאה a,b=b,a+b; return a — איטרטיבי, O(n) זמן ו-O(1) זיכרון

תשובה: ד

✓ תשובה: ד) Iterative עם שני משתנים — הפתרון הנכון: def fib(n): a,b=0,1 \n for _ in range(n): a,b=b,a+b \n return a. זמן O(n), זיכרון O(1). Recursive א') = O(2^n) — איטי מאוד. ד') = O(n) זמן אבל O(n) זיכרון. בוחן מחפש Iterative (לא Recursive) + מינימל זיכרון. שני משתנים = הפתרון הקלאסי.

גאמא סגנון ב׳ — STAR בפועל · הבוחן: "מה תעשה אם נדרש ממך לעבוד עם טכנולוגיה שמעולם לא ראית?" מה התשובה הכי טובה?

א. “אני פשוט לומד כל טכנולוגיה חדשה במהירות רבה מאוד וללא כל קושי”
ב. “עשיתי בדיוק את זה בסדנה: dir() ו-help(), הרצת Example, מימוש בחצי שעה”
ג. “אני מחפש סרטוני Tutorials מתאימים ב-YouTube ולומד מהם צעד-צעד”
ד. “אני פונה ומבקש עזרה מעמיתים לצוות שכבר מכירים את הטכנולוגיה”

תשובה: ב

✓ תשובה: ב) דוגמה ספציפית + שיטה — זוהי תשובת STAR מושלמת: [S] "בסדנה", [A] "dir() → help() → Example → ממשתי", [R] "30 דקות". תשובות א'-ג' = טענות ריקות ללא הוכחה. תשובה ד' = הוכחה + שיטה קונקרטית. הבוחן רוצה Evidence, לא Claims.

גאמא סגנון ג׳ — שאלת ידע + Tradeoff · הבוחן: "מתי HTTP/2 עדיף על HTTP/1.1?" מה תשובה שמראה Depth?

def merge_intervals(intervals: list) -> list:
    if not intervals: return []
    it = sorted(intervals)
    res = [list(it[0])]
    for s, e in it[1:]:
        if s <= res[-1][1]: res[-1][1] = max(res[-1][1], e)  # חופף -> מיזוג
        else: res.append([s, e])
    return res

א. “HTTP/2 עדיף תמיד ובכל מצב, מהסיבה הפשוטה שהוא הפרוטוקול החדש”
ב. “דווקא HTTP/1.1 עדיף תמיד, מכיוון שהוא נתמך בהרבה יותר מערכות”
ג. “כשיש הרבה Resources קטנים — Multiplexing שולח הכל ב-Connection אחד”
ד. “אני לא ממש מכיר את הפרוטוקול HTTP/2 ולכן קשה לי להשוות ביניהם”

תשובה: ג

✓ תשובה: ג) — זוהי תשובה עם Depth: מסבירה מדוע (Multiplexing), מתי (resources קטנים), ומתי פחות רלוונטי (API requests גדולות). ב') = כללי ולא מדויק (לא "תמיד"). ג') = מוטעה. ד') = לא יודע + עצירה (Anti-Pattern). אפשר לומר "לא מכיר לעומק" אם אמת — אבל לנסות להסיק מה שיודעים על HTTP.

← שיעור קודם שיעור 50 →