בגרות מדעי המחשב 899271, קיץ 2026 מועד א'

תאריך הבחינה: 4.6.2026

טופס המבחן המלא להורדה — ומפתח התשובות עם פתרון מפורט לכל שאלה, אונליין. פתחו שאלה למטה: בשאלה סגורה בוחרים תשובה, בשאלה פתוחה נפתח הפתרון המלא (כניסה מהירה וחינם).

📄 הורדת טופס המבחן (PDF) ←

פתרו את המבחן אונליין — בשפה שלכם:Java ←C# ←

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

✓ פתרון מלא לכל שאלה · ✓ הסברים מלאים וחומרי לימוד · ✓ ליווי מורה AI · ✓ התחלה חינם

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

שאלות לדוגמה מהמבחן — פתרו עכשיו

בשאלה סגורה בוחרים תשובה; בשאלה פתוחה פותחים את הפתרון המלא (כניסה מהירה וחינם). אלו 3 מתוך 12 שאלות המבחן — את כולן תוכלו לפתור אונליין.

שאלה 1

נתונה המחלקה Order - הזמנה של לקוח, ולה שתי תכונות: id - מספר זהות של הלקוח (שלם), count - כמות המוצרים שהוזמנו (שלם). יש לה get/set וקונסטרוקטור:

בחברת המשלוחים "ברק" נבנה תור qOrder מטיפוס Order, השומר את הזמנות הלקוחות ביום מסוים. ייתכן שאותו לקוח (id) יופיע כמה פעמים בתור (כמה הזמנות באותו יום), ומיקום ההזמנות בתור אינו לפי סדר כלשהו. בסוף היום מבצעים בתור חדש איחוד הזמנות לפי מזהה לקוח (id): לכל לקוח נשמרת הזמנה אחת בלבד, עם סך כל המוצרים שהוא הזמין. דוגמה: 3 הזמנות של אותו לקוח - 20, 15, 30 מוצרים - הופכות לאחר האיחוד להזמנה אחת של 65 מוצרים.

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

public class Order { int id; int count; /* get/set + constructor as described */ }

סעיף א(1)

ממשו את הפעולה שלפניכם: הפעולה מקבלת תור שיש בו הזמנות – qOrder – ובו אותו לקוח יכול להופיע יותר מפעם אחת, ומחזירה תור חדש ובו יש איחוד הזמנות כפי שהוסבר לעיל. הערות: – אין חשיבות לסדר ההזמנות לאחר איחוד ההזמנות. – אין להשתמש בסעיף זה במערך או ברשימה או במבנה נתונים אחר פרט לתור (או בשום מבנה נגדית שיש בו גרסה נגדית דוגמה אחר פרט לתור). פתרון הכולל שימוש בהם לא יזוכה בנקודות. – אפשר לשנות את התור שהתקבל.

public static Queue<Order> uniteOrders (Queue<Order> qOrder)

סעיף א(2)

מהי סיבוכיות זמן הריצה של הפעולה? נמקו את תשובתכם.

סעיף ב(1)

"לקוח רגיל" הוא לקוח שהזמין לקוח שהזמין פחות מ-10 מוצרים סך הכול ביום מסוים, ו"לקוח מועדף" הוא לקוח שהזמין 10 מוצרים ומעלה סך הכול ביום מסוים. ממשו את הפעולה שלפניכם: הפעולה מקבלת תור הזמנות של יום מסוים – qOrder מטיפוס Order (תור "לא מאוחד", שבו אותו לקוח יכול להופיע כמה פעמים), ומחזירה תור חדש שבו כל מי שהוא "לקוח מועדף" יופיעו מספרי הזהות (id) של כל מי שהוא "לקוח רגיל" (של סדר הלקוחות בכל קבוצה). אפשר להשתמש בפעולה שכתבתם בסעיף א. הערות: – כל לקוח (id) יופיע פעם אחת בלבד בתור המוחזר. – אין להשתמש בסעיף זה במערך או ברשימה או במבנה נתונים אחר פרט לתור (או בשום מבנה נתונים אחר פרט לתור). פתרון הכולל שימוש בהם לא יזוכה בנקודות. – אפשר לשנות את התור שהתקבל.

public static Queue<Integer> preferredClients (Queue<Order> qOrder)

סעיף ב(2)

שאלה 2

נתונות שתי הפניות לראשי שרשרות של חוליות (מטיפוס Node<T> הסטנדרטי, עם הפעולות getValue/setValue/getNext/setNext ב-Java, GetValue/SetValue/GetNext/SetNext ב-C#): numHead - הפנייה לשרשרת חוליות של מספרים שלמים. charHead - הפנייה לשרשרת חוליות מטיפוס תו (char), שבה מיוצגות פעולות החשבון חיבור וחיסור ('+','-'). כמות החוליות בשרשרת המספרים גדולה ב-1 מכמות החוליות בשרשרת התווים (אין פעולת חשבון לפני המספר הראשון).

שילוב בין שתי השרשרות מייצג סדרת פעולות חשבון: התו במיקום 1 בשרשרת התווים מתאר את הפעולה שבאה לפני המספר שבמיקום 2 בשרשרת המספרים, התו במיקום 2 מתאר את הפעולה שבאה לפני המספר שבמיקום 3, וכן הלאה עד סוף השרשרות.

דוגמה (המשמשת לאורך השאלה כולה):

numHead:  [1]3 -> [2]5 -> [3]2 -> [4]3 -> [5]7 -> null
charHead: [1]+ -> [2]- -> [3]- -> [4]+ -> null

שרשראות אלה מייצגות את סדרת פעולות החשבון: 3 + 5 − 2 − 3 + 7 (=10).

שתי שרשרות מקושרות חד-כיווניות מקבילות: numHead (חוליות מספרים) ו-charHead (חוליות תווי פעולה).

numHead: [1]3 -> [2]5 -> [3]2 -> [4]3 -> [5]7 -> null
charHead: [1]+ -> [2]- -> [3]- -> [4]+ -> null

סעיף א

ממשו את הפעולה שלפניכם: len הוא כמות המספרים שנדרשה לחשב מתוך שרשרת המספרים (אין פעולת חשבון לפני המספר הראשון ולכן כמות התווים היא len-1 בהתאם). הפעולה תחזיר את תוצאת החישוב ברצף של len מספרים, החל מתחילת שרשרת המספרים ותחילת שרשרת התווים. הניחו ש-len גדול מ-0. אין לשנות את השרשרות שהתקבלו. הערה: אם len גדול מכמות החוליות בשרשרת המספרים, הפעולה תחזיר את תוצאת החישוב של כל המספרים בשרשרת. דוגמה: בעבור שתי השרשרות בדוגמה שלעיל ו-len=1, הפעולה תחזיר 3, כיוון שהוא המספר הראשון בשרשרת המספרים (היות שהוא המספר הראשון והיחיד, אין שום פעולת חשבון שצריך לבצע). דוגמה נוספת: בעבור אותן שתי שרשרות ו-len=3, הפעולה תחזיר 6 (3+5-2=6). דוגמה נוספת: בעבור אותן שתי שרשרות ו-len=8, הפעולה תחזיר 10 (3+5-2-3+7=10). הסבר: מספר החוליות בשרשרת המספרים קטן מ-8, ולכן הפעולה מחזירה את תוצאת החישוב של כל המספרים בשרשרת.

public static int eval (Node<Integer> numHead, Node<Character> charHead, int len)

סעיף ב

ממשו את הפעולה שלפניכם: הפעולה תחזיר true אם קיימת חוליה במיקום כלשהו בשרשרת המספרים וחוליה במיקום זהה בשרשרת התווים, שמהם והלאה יש len מספרים ברצף שתוצאת החישוב שלהם היא val (כלומר אם מתחילים את החישוב מן החוליה השנייה בשרשרת המספרים, גם פעולת החשבון הראשונה תהיה החוליה השנייה בשרשרת התווים). אחרת הפעולה תחזיר false. אפשר להשתמש בפעולה שכתבתם בסעיף א. הניחו ש-len גדול מ-0. אין לשנות את השרשרות שהתקבלו. שימו לב: אין פעולת חשבון לפני המספר הראשון בחישוב (מספר התווים הנדרש הוא len-1). הערה: אם מחוליה כלשהי יש פחות מ-len מספרים עד סוף השרשרת - החישוב מתבצע עד סוף השרשרת. דוגמה: בעבור שתי השרשרות המוצגות בדוגמה שלעיל, ו-len=3 ו-val=0, הפעולה תחזיר true, כי החל מן החוליה השנייה בשרשרת המספרים ומן החוליה השנייה בשרשרת התווים יש 3 מספרים ברצף שתוצאת החישוב שלהם היא 0 (5-2-3=0). דוגמה נוספת: בעבור שתי השרשרות המוצגות בדוגמה שלעיל, ו-len=3 ו-val=10, הפעולה תחזיר true, כי החל מן החוליה הרביעית בשרשרת המספרים ומן החוליה הרביעית בשרשרת התווים ועד סוף שרשרת המספרים תוצאת החישוב היא 10 (3+7=10).

public static boolean match (Node<Integer> numHead, Node<Character> charHead, int len, int val)

שאלה 3

שימו לב: לשאלה זו שני נוסחים שקולים - Java (עמודים 6-7) ו-C# (עמודים 8-9). נתונות הפעולות הרקורסיביות הבאות על עץ בינרי (BinNode<T>, עם הפעולות getValue/getLeft/getRight/setLeft/setRight/hasLeft/hasRight ב-Java, GetValue/GetLeft/GetRight/SetLeft/SetRight/HasLeft/HasRight ב-C#):

עץ 1 (לסעיף א(1)):

עץ 2 (לסעיפים א(2) ו-ב(1)):

public static int foo (BinNode<Integer> tree) {
    if (tree.getLeft() == null && tree.getRight() == null)
        return 0;
    if (tree.getLeft() == null)
        return foo (tree.getRight()) + 1;
    if (tree.getRight() == null)
        return foo (tree.getLeft()) - 1;
    return foo (tree.getLeft()) + foo (tree.getRight());
}

public static boolean goo (BinNode<Integer> tree) {
    if (tree == null)
        return true;
    if (foo (tree) != 0)
        return false;
    return goo (tree.getLeft()) && goo (tree.getRight());
}

עץ 1 (foo, סעיף א(1)): שורש 5, אין בן שמאלי, בן ימני 9; ל-9 אין בן שמאלי, בן ימני 7; ל-7 בן שמאלי 0 ובן ימני 3 (שניהם עלים).

tree->5
5.right->9
9.right->7
7.left=0 (leaf), 7.right=3 (leaf)

עץ 2 (foo, סעיף א(2), זהה גם ל-goo בעמודים 7/9): שורש 5, בן ימני בלבד 1; ל-1 בן שמאלי 0 ובן ימני 7; ל-0 בן שמאלי בלבד 2; ל-2 בן שמאלי בלבד 4 (עלה); ל-7 בן ימני בלבד 3 (עלה).

tree->5
5.right->1
1.left->0, 1.right->7
0.left->2
2.left->4 (leaf)
7.right->3 (leaf)

סעיף א(1)

בצעו מעקב אחרי הפעולה foo והעץ שלפניכם, וכתבו מה הפעולה מחזירה. יש להציג את המעקב.

foo(tree)

סעיף א(2)

סעיף א(3)

בעבור עץ שיש לו 6 צמתים, מהו המספר הכי גבוה שהפעולה foo יכולה להחזיר? הציגו את העץ.

סעיף א(4)

בעבור עץ שיש לו 6 צמתים, מהו המספר הכי נמוך שהפעולה foo יכולה להחזיר? הציגו את העץ.

סעיף א(5)

כתבו בקצרה מה הפעולה foo מחזירה בעבור עץ כלשהו שאינו ריק.

סעיף ב(1)

בצעו מעקב אחרי הפעולה goo והעץ שלפניכם, וכתבו מה הפעולה מחזירה. יש להציג את המעקב. בסעיף זה אין צורך להציג מעקב אחרי הפעולה foo.

goo(tree)

סעיף ב(2)

הציגו עץ שיש לו 3 צמתים שבעבורו הפעולה goo תחזיר תוצאה הפוכה מן התוצאה שהתקבלה בתת-סעיף ב(1).

פתרו את המבחן המלא — עם משוב על כל תשובה

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

התחילו לתרגל — חינם ←

→ לכל מבחני שאלון 899271

שאלות לדוגמה מהמבחן — פתרו עכשיו

פתרו את המבחן המלא — עם משוב על כל תשובה

לא עוד דף פתרונות — כאן מתרגלים, נבחנים ומשתפרים