divicidivici·איזיפס·פשוט להצליח

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

תאריך הבחינה: לא ידוע

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

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

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

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

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

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

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

שאלה 1

לפניכם המחלקה Ring (טבעת) בעלת גודל ("S"/"M"/"L") וצבע, והמחלקה Pole (מוט) המספקת פעולות add (הכנסה לראש המוט, O(1)), remove (הוצאה מהראש, O(1)), isEmpty (O(1)) ו-sort (למימוש). לאחר sort(), הטבעות הגדולות צריכות להיות מונחות בתחתית המוט והקטנות מעליהן.

public class Ring {
    private String size;   // גודל הטבעת ("S"/"M"/"L")
    private int color;     // צבע הטבעת
    public Ring() { this.size = "L"; this.color = 0; }
    public Ring(String str, int c) { this.size = str; this.color = c; }
    public String getSize() { return this.size; }
    public int getColor() { return this.color; }
}

public class Pole {
    private java.util.LinkedList<Ring> data = new java.util.LinkedList<>();
    public Pole() { }
    public void add(Ring r) { data.addFirst(r); }          // O(1) — מכניסה טבעת r לראש המוט
    public Ring remove() { return data.removeFirst(); }     // O(1) — מוציאה ומחזירה את טבעת הראש
    public boolean isEmpty() { return data.isEmpty(); }      // O(1)
    public void sort() {
        // TODO — סעיף א
    }
}
סעיף א

ממש ב-Java את הפעולה sort() (ב-C#: Sort()) שבמחלקה Pole, המסדרת את הטבעות כך שהגדולות "מונחות" בתחתית המוט והקטנות מעליהן. בתשובתך השתמש רק בפעולות המחלקות Pole ו-Ring.

public void sort()

סעיף ב

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

שאלה 2

מוגדרת "רשימה דו-כיוונית" כאוסף סדור של חוליות BinNode<Integer> המקושרות כך שלכל זוג חוליות p1,p2: אם p1.getRight()==p2 אז p2.getLeft()==p1 (יש לפחות שתי חוליות). כלומר כל חוליה — חוץ מהחוליה שבקצה הימני והחוליה שבקצה השמאלי — מצביעה על החוליה שלפניה ועל החוליה שלאחריה. בדוגמה שבשאלון: הרשימה 13-10-27-11-8 (null בקצה שמאל, null בקצה ימין), ומשתנה pos מצביע על החוליה עם הערך 11.

public class BinNode<T> {
    private T value;
    private BinNode<T> left;   // ברשימה דו-כיוונית: החוליה השמאלית (הקודמת)
    private BinNode<T> right;  // ברשימה דו-כיוונית: החוליה הימנית (הבאה)
    public BinNode(T value) { this.value = value; this.left = null; this.right = null; }
    public T getValue() { return value; }
    public void setValue(T value) { this.value = value; }
    public BinNode<T> getLeft() { return left; }
    public void setLeft(BinNode<T> left) { this.left = left; }
    public BinNode<T> getRight() { return right; }
    public void setRight(BinNode<T> right) { this.right = right; }
}
// "רשימה דו-כיוונית": לכל זוג חוליות p1,p2 — אם p1.getRight()==p2 אז p2.getLeft()==p1.

הרשימה הדו-כיוונית שבדוגמה, pos מצביע על החוליה עם הערך 11

null <- [13] <-> [10] <-> [27] <-> [11] <-> [8] -> null
                                        ^pos
סעיף א

לפניך שלד הפעולה firstLeft (ב-C#: FirstLeft) המקבלת pos שונה מ-null מטיפוס BinNode<Integer> המצביע על חוליה כלשהי ברשימה דו-כיוונית, ומחזירה את החוליה השמאלית ביותר ברשימה. העתק את השלד למחברתך והשלם אותו כך שהפעולה תבצע את הנדרש.

public static BinNode<Integer> firstLeft(BinNode<Integer> pos)

סעיף ב1

עקוב אחר ביצוע הפעולה what(pos) בעבור המשתנה pos והרשימה הדו-כיוונית שבדוגמה שהוצגה בתחילת השאלה. במעקב הראה את ערכי המשתנים pos, left, right, sum.

סעיף ב2

קבע אם אפשר או אי אפשר להחליף את 3 השורות האחרונות שבפעולה בשורה המקופלת במסגרת (return left.getValue()+right.getValue()==sum;). נמק את קביעתך.

שאלה 3

"עץ מספרים" הוא עץ בינארי לא ריק מטיפוס BinNode<Integer> שהערכים שלו הם מספרים שלמים וגדולים מ-0. על עץ מספרים מוגדרת פעולת "מסלול-עולה": המחזירה true אם יש בעץ מסלול המתחיל בשורש ומסתיים בעלה, ועל-פי ערכי הצמתים ממורש בסדר עולה ממש בהשוואה בין כל שני צמתים סמוכים בו; אם אין מסלול כזה — מחזירה false. בדוגמה: בעבור עץ המספרים tr1 הפעולה "מסלול-עולה" מחזירה true (המסלול מוצף בקו שבור); בעבור עץ המספרים tr2 הפעולה "מסלול-עולה" מחזירה false.

public class BinNode<T> {
    private T value;
    private BinNode<T> left;   // בעץ מספרים: הבן השמאלי
    private BinNode<T> right;  // בעץ מספרים: הבן הימני
    public BinNode(T value) { this.value = value; this.left = null; this.right = null; }
    public T getValue() { return value; }
    public void setValue(T value) { this.value = value; }
    public BinNode<T> getLeft() { return left; }
    public void setLeft(BinNode<T> left) { this.left = left; }
    public BinNode<T> getRight() { return right; }
    public void setRight(BinNode<T> right) { this.right = right; }
}
// כאן BinNode<T> משמש לייצוג עץ בינארי: getLeft/getRight הם הבנים השמאלי/ימני.

tr1 (upPath=true, המסלול 1→2→17→19 מסומן) ו-tr2 (upPath=false)

tr1:                                   tr2:
            1                                       1
         /     \                                 /     \
        6       2*                               6       7
       / \     / \                              / \     / \
      3   4  17* 11                             3   4  14   2
       \      / \   \                            \      / \   \
        8   19* 12  10                             8   9   11  10
       /                                          /
      5                                          5
(* = על המסלול העולה 1->2->17->19, לפי הסימון בשאלון)
סעיף א

ממש ב-Java (או C#) את הפעולה "מסלול-עולה" בעבור עץ מספרים tr.

public static boolean upPath(BinNode<Integer> tr)

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

לפי סדר המבחן. לוחצים על שאלה ועוברים לעמוד שלה: השאלה המלאה, השרטוט, ופתרון מלא ומוסבר צעד אחרי צעד.

  1. שאלה 4

    שאלה 4 — מיון טבעות על מוט (ADT מחסנית)

  2. שאלה 5

    שאלה 5 — רשימה דו-כיוונית — קצוות וסכום-סימטרי

  3. שאלה 6

    שאלה 6 — עץ מספרים — מסלול עולה

  4. שאלה 10

    שאלה 10 — גרף מכוון ממטריצת שכנות — רכיבי קשירות חזקה (קטע מותאם)

  5. שאלה 11

    שאלה 11 — שפות רגולריות — סגירות ובניית DFA

  6. שאלה 12

    שאלה 12 — מכונת טיורינג — מיון שלושה מספרים מודולו 3

  7. שאלה 13

    שאלה 13 — היררכיית ירושה — בדיקות קומפילציה ועיצוב מחלקה

  8. שאלה 14

    שאלה 14 — הצללת שדות ודריסת פעולות — עצי ירושה A/B

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

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

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

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

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

וכמובן — פתרון מלא ומוסבר לכל שאלה מהבגרויות האמיתיות. מתחילים לתרגל — חינם, בלי כרטיס ←