דילוג לתוכן המרכזי

מבחן מה"ט מבנה נתונים ותכנות מונחה עצמים 97105 - אביב 2022 מועד א'

הנדסת תוכנה · סמל 97105 · 11 שאלות · פתרון מלא לכל סעיף

מבחן הגמר הממלכתי של מה"ט במבנה נתונים ותכנות מונחה עצמים, אביב 2022 מועד א', כל 11 השאלות כמו בשאלון. לכל סעיף יש תשובה סופית ופתרון מלא ומוסבר, צעד אחרי צעד. נסו לפתור לבד, ואז פתחו את הפתרון.

הנחיות הבחינה

משך הבחינה: ארבע שעות וחצי.

מבנה השאלון: בשאלון זה שני מבחנים, עליכם לענות על מבחן אחד בלבד בהתאם למוסד הלימודים:

מבחן ב- Java (עמוד 2)

מבחן ב- C# (עמוד 15)

בכל מבחן 11 שאלות.

חלק א' – 45 נקודות

שאלות 1-4: יש לענות על שלוש שאלות בלבד. ערך כל שאלה 15 נקודות.

חלק ב' – 30 נקודות

שאלות 5-8: יש לענות על שתי שאלות בלבד. ערך כל שאלה 15 נקודות.

חלק ג' – 25 נקודות

שאלות 9-11: יש לענות על שתי שאלות בלבד. ערך כל שאלה 12 נקודות.

נקודה אחת תינתן על הערכה.

בסך הכול: 100 נקודות.

חומר עזר: 1. מחשבון (אין להשתמש במחשב כף יד או במחשבון עם תקשורת חיצונית).

2. קלסר אחד בלבד עם חומר ההרצאות. אין להוציא דפים מהקלסר.

אין לצרף ספרים או חוברות עם פתרונות.

שאלה 1 · הכפלת שרשרת חוליות בשתי דרכים

א.

כתבו פעולה המקבלת הפניה לחוליה ראשונה בשרשרת חוליות של מספרים שלמים ו"מכפילה" את השרשרת בצורה הבאה:

אם לפני זימון הפעולה השרשרת הייתה: `1 -> 2 -> 3 -> 4 -> null`

אז אחרי זימון הפעולה היא תהיה: `1 -> 1 -> 2 -> 2 -> 3 -> 3 -> 4 -> 4 -> null`

כותרת הפעולה: `public static void first(Node<Integer> chain)`

(במבחן ב-C#: `public static void First(Node<int> chain)`)

(8 נקודות)
ב.

כתבו פעולה המקבלת הפניה לחוליה ראשונה בשרשרת חוליות של מספרים שלמים ו"מכפילה" את השרשרת בצורה הבאה:

אם לפני זימון הפעולה השרשרת הייתה `11 -> 2 -> 30 -> 4 -> null`

אז אחרי זימון הפעולה היא תהיה `11 -> 2 -> 30 -> 4 -> 11 -> 2 -> 30 -> 4 -> null`

כותרת הפעולה: `public static void second(Node<Integer> chain)`

(במבחן ב-C#: `public static void Second(Node<int> chain)`)

(7 נקודות)
◂ פתרון מלא לשאלה 1

סעיף א

תשובה:

פעולה שמוסיפה אחרי כל חוליה עותק שלה ומתקדמת שני צעדים.

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

1. יוצרים חוליה `copy` שערכה כערך `p`, והעוקבת שלה היא העוקבת הנוכחית של `p`: `new Node<Integer>(p.getValue(), p.getNext())`.

2. מחברים: `p.setNext(copy)` – עכשיו העותק נמצא מיד אחרי `p`, ושאר השרשרת נשמרה אחריו.

3. מקדמים: `p = copy.getNext()` – זו החוליה המקורית הבאה (או null בסוף השרשרת).

4. הלולאה נעצרת כש-`p == null`. שרשרת ריקה (`chain == null`) – הלולאה לא מתבצעת כלל, ואין חריגה.

Java:

public static void first(Node<Integer> chain)
{
    Node<Integer> p = chain;
    while (p != null)
    {
        // חוליה חדשה עם אותו ערך, שמצביעה על העוקבת של p
        Node<Integer> copy = new Node<Integer>(p.getValue(), p.getNext());
        p.setNext(copy);          // החוליה החדשה נכנסת מיד אחרי p
        p = copy.getNext();       // מדלגים על העותק אל החוליה המקורית הבאה
    }
}

C#:

public static void First(Node<int> chain)
{
    Node<int> p = chain;
    while (p != null)
    {
        // חוליה חדשה עם אותו ערך, שמצביעה על העוקבת של p
        Node<int> copy = new Node<int>(p.GetValue(), p.GetNext());
        p.SetNext(copy);          // החוליה החדשה נכנסת מיד אחרי p
        p = copy.GetNext();       // מדלגים על העותק אל החוליה המקורית הבאה
    }
}

בדיקה בדוגמה: `p` עובר על 1, 2, 3, 4 (המקוריות), ואחרי כל אחת נוסף עותק: `1 -> 1 -> 2 -> 2 -> 3 -> 3 -> 4 -> 4 -> null`.

יעילות: כל חוליה מקורית מטופלת פעם אחת – O(n)O(n).

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

סעיף ב

תשובה:

פעולה שמוסיפה בסוף השרשרת עותק של כל החוליות המקוריות, עד החוליה האחרונה המקורית.

הרעיון: צריך להוסיף בסוף השרשרת עותק של כל השרשרת המקורית, באותו סדר. הסכנה כאן היא לולאה אין-סופית: אם נעתיק "עד ש-p מגיע ל-null", הרי שבזמן ההעתקה השרשרת גדלה, ו-`p` ימשיך להעתיק גם את העותקים. לכן קודם מסמנים את החוליה האחרונה המקורית (`last`), ומעתיקים עד שמעתיקים אותה.

1. אם השרשרת ריקה – אין מה להכפיל, יוצאים.

2. מוצאים את החוליה האחרונה `last` (לולאה עד `!last.hasNext()`).

3. `tail` מצביע תמיד על סוף השרשרת. בתחילה `tail = last`.

4. `p` עובר על החוליות המקוריות מההתחלה: לכל אחת יוצרים חוליה חדשה עם אותו ערך, מחברים אותה אחרי `tail` ומקדמים את `tail` אליה.

5. כשהעתקנו את `last` (כלומר `p == last`) – סיימנו; העותקים לא מועתקים שוב.

Java:

public static void second(Node<Integer> chain)
{
    if (chain == null)
        return;
    // מציאת החוליה האחרונה בשרשרת המקורית
    Node<Integer> last = chain;
    while (last.hasNext())
        last = last.getNext();

    Node<Integer> tail = last;    // סוף השרשרת – אליו מוסיפים את העותקים
    Node<Integer> p = chain;
    boolean done = false;
    while (!done)
    {
        tail.setNext(new Node<Integer>(p.getValue()));
        tail = tail.getNext();
        if (p == last)            // העתקנו את החוליה המקורית האחרונה
            done = true;
        else
            p = p.getNext();
    }
}

C#:

public static void Second(Node<int> chain)
{
    if (chain == null)
        return;
    // מציאת החוליה האחרונה בשרשרת המקורית
    Node<int> last = chain;
    while (last.HasNext())
        last = last.GetNext();

    Node<int> tail = last;    // סוף השרשרת – אליו מוסיפים את העותקים
    Node<int> p = chain;
    bool done = false;
    while (!done)
    {
        tail.SetNext(new Node<int>(p.GetValue()));
        tail = tail.GetNext();
        if (p == last)            // העתקנו את החוליה המקורית האחרונה
            done = true;
        else
            p = p.GetNext();
    }
}

בדיקה בדוגמה: `last` היא החוליה 4. `p` עובר על 11, 2, 30, 4, ובכל פעם נוספת חוליה בסוף: `11 -> 2 -> 30 -> 4 -> 11 -> 2 -> 30 -> 4 -> null`. אחרי העתקת 4 (`p == last`) הלולאה נעצרת.

יעילות: מעבר אחד למציאת הסוף ומעבר אחד להעתקה – O(n)O(n).

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

שאלה 2 · סידור מחסנית סביב ממוצע האיברים

א.

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

לדוגמה:

ממוצע איברי המחסנית הוא: (5+7+10+2+12+6)/6=7(5+7+10+2+12+6)/6=7

(12 נקודות)
ב.

מהי הסיבוכיות של הפעולה שכתבתם בסעיף א'? הסבירו את תשובתכם

(3 נקודות)
◂ פתרון מלא לשאלה 2

סעיף א

תשובה:

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

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

1. סכום ומספר איברים: מוציאים את כל האיברים מ-`st` אל מחסנית עזר `temp`, ובדרך צוברים את הסכום `sum` וסופרים `count`. הממוצע: `avg = (double) sum / count` (חילוק ממשי, כדי לא לאבד את החלק השברי).

2. חלוקה: מוציאים את האיברים מ-`temp`; איבר הגדול מ-`avg` נדחף למחסנית `big`, ואיבר קטן או שווה לממוצע – למחסנית `small`.

3. בנייה מחדש: קודם מעבירים ל-`st` את כל האיברים של `small` – הם נכנסים ראשונים ולכן יהיו בתחתית; אחר כך מעבירים את כל האיברים של `big` – הם יהיו בחלק העליון.

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

Java:

public static void sortByAverage(Stack<Integer> st)
{
    if (st.isEmpty())
        return;
    Stack<Integer> temp = new Stack<Integer>();
    int sum = 0, count = 0;
    // מעבר 1: חישוב סכום ומספר האיברים (האיברים עוברים ל-temp)
    while (!st.isEmpty())
    {
        int x = st.pop();
        sum += x;
        count++;
        temp.push(x);
    }
    double avg = (double) sum / count;

    // מעבר 2: חלוקה לשתי מחסניות עזר לפי הממוצע
    Stack<Integer> big = new Stack<Integer>();     // גדולים מהממוצע
    Stack<Integer> small = new Stack<Integer>();   // קטנים או שווים לממוצע
    while (!temp.isEmpty())
    {
        int x = temp.pop();
        if (x > avg)
            big.push(x);
        else
            small.push(x);
    }

    // מעבר 3: קודם הקטנים (יהיו בתחתית), ואחריהם הגדולים (יהיו למעלה)
    while (!small.isEmpty())
        st.push(small.pop());
    while (!big.isEmpty())
        st.push(big.pop());
}

C#:

public static void SortByAverage(Stack<int> st)
{
    if (st.IsEmpty())
        return;
    Stack<int> temp = new Stack<int>();
    int sum = 0, count = 0;
    // מעבר 1: חישוב סכום ומספר האיברים (האיברים עוברים ל-temp)
    while (!st.IsEmpty())
    {
        int x = st.Pop();
        sum += x;
        count++;
        temp.Push(x);
    }
    double avg = (double) sum / count;

    // מעבר 2: חלוקה לשתי מחסניות עזר לפי הממוצע
    Stack<int> big = new Stack<int>();     // גדולים מהממוצע
    Stack<int> small = new Stack<int>();   // קטנים או שווים לממוצע
    while (!temp.IsEmpty())
    {
        int x = temp.Pop();
        if (x > avg)
            big.Push(x);
        else
            small.Push(x);
    }

    // מעבר 3: קודם הקטנים (יהיו בתחתית), ואחריהם הגדולים (יהיו למעלה)
    while (!small.IsEmpty())
        st.Push(small.Pop());
    while (!big.IsEmpty())
        st.Push(big.Pop());
}

בדיקה בדוגמה: sum=5+7+10+2+12+6=42sum=5+7+10+2+12+6=42, count=6count=6, ולכן avg=426=7avg=\frac{42}{6}=7. הגדולים מ-7: 10, 12; הקטנים או שווים ל-7: 5, 7, 2, 6. אחרי הפעולה המחסנית (מהראש לתחתית) היא: 12, 10 | 6, 2, 7, 5 – הגדולים למעלה והקטנים למטה, כמו בדוגמה (הסדר בתוך כל חלק אינו חשוב).

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

סעיף ב

תשובה:

O(n)O(n)

נסמן ב-nn את מספר האיברים במחסנית. כל פעולות המחסנית (`push`, `pop`, `isEmpty`) הן O(1)O(1) (לפי הנספח).

1. מעבר 1: כל אחד מ-nn האיברים מוצא מ-`st` ונדחף ל-`temp` – nn צעדים קבועים.

2. מעבר 2: כל איבר מוצא מ-`temp` ונדחף ל-`big` או ל-`small` – שוב nn צעדים.

3. מעבר 3: כל איבר מוצא מ-`small` או מ-`big` ונדחף ל-`st` – nn צעדים.

בסך הכול כל איבר עובר מספר קבוע של פעמים (3 העברות), ולכן זמן הריצה הוא 3n⋅O(1)=O(n)3n\cdot O(1)=O(n) – סיבוכיות לינארית.

תשובה: O(n)O(n) – שלושה מעברים על האיברים, כל אחד בפעולות O(1)O(1).

שאלה 3 · ירושה, הרשאות גישה ודריסת פעולות

א.

נתון קטע קוד שרץ ללא שגיאות:

Java:

A x = new B(t, s);
h.g(n, d);

C#:

A x = new B(t, s);
h.G(n, d);

עבור כל אחד מההיגדים 1-6 ציינו האם הוא נכון או אינו נכון. הסבירו את תשובתכם.

1. הפעולה g חייבת להיות ציבורית (public).

2. t הוא בהכרח משתנה מטיפוס פשוט (כמו: int, double וכד').

3. h הוא בהכרח אובייקט.

4. d יכול להיות שם של פעולה.

5. B היא בהכרח מחלקה שיורשת מ- A (גם אם לא ישירות).

6. ייתכן ש- A היא מחלקה שיורשת מ- B.

(9 נקודות)
ב.

(אין קשר לסעיף א')

נתונה המחלקה A הבאה:

Java:

public class A
{
   protected void a1()
   {
     System.out.println ("Hello A");
   }
   protected void a2()
   {
    a1();
   }
}

C#:

public class A
{
   protected virtual void A1()
    {
     Console.WriteLine ("Hello A");
    }
   protected void A2()
   {
    A1();
   }
}

בקובץ נפרד, הגדירו מחלקה נוספת B שיורשת מהמחלקה A. במחלקה B ביצעו דריסה לפעולה a1 והיא מדפיסה "Bye B".

מה יקרה אם נפעיל על אובייקט מסוג B את הפעולה a2?

1. הפלט יהיה: `Hello A`

2. הפלט יהיה: `Bye B`

3. הפלט יהיה:

Hello A
Bye B

4. הפלט יהיה:

Bye B
Hello A
(6 נקודות)
◂ פתרון מלא לשאלה 3

סעיף א

תשובה:

1 – לא נכון; 2 – לא נכון; 3 – לא נכון; 4 – לא נכון; 5 – נכון; 6 – לא נכון.

מה ידוע מהקוד: בשורה הראשונה נוצר עצם חדש מהמחלקה B בעזרת בנאי שמקבל שני פרמטרים, וההפניה אליו נשמרת במשתנה מטיפוס A. בשורה השנייה מזמנים פעולה g עם שני ארגומנטים דרך h. בודקים כל היגד מול מה שהשפה מאפשרת.

1. לא נכון. הרשאת הגישה הנדרשת תלויה במקום שבו נמצא הקוד. אם הקוד כתוב בתוך המחלקה של h, הפעולה g יכולה להיות גם private; אם הוא באותה חבילה (Java) – גם protected או בלי מציין גישה. public נדרש רק כשמזמנים מכל מקום.

2. לא נכון. t הוא ארגומנט לבנאי של B, והבנאי יכול לקבל כל טיפוס – גם הפניה לעצם (למשל String או מערך).

3. לא נכון. h יכול להיות גם שם של מחלקה, ואז g היא פעולה סטטית (static) של המחלקה, כמו `Math.max(n, d)`.

4. לא נכון. ארגומנט בזימון פעולה הוא ביטוי שיש לו ערך – משתנה, קבוע או ביטוי. שם של פעולה לבדו (בלי סוגריים) אינו ערך שאפשר להעביר כך כפרמטר. (הערה ל-C#: מחוץ לחומר הקורס, בשפה קיימים delegates, שבאמצעותם אפשר להעביר שם של פעולה כארגומנט; בחומר הנלמד התשובה היא "לא נכון".)

5. נכון. משתנה מטיפוס A יכול להפנות רק לעצם שהוא "סוג של" A. לכן B חייבת להיות צאצאית של A – ישירות או דרך מחלקות ביניים (ואם A היא ממשק – B מממשת אותו, בעצמה או דרך מחלקת-אב).

6. לא נכון. אם A הייתה יורשת מ-B, אז B הייתה המחלקה הכללית, ועצם מטיפוס B אינו בהכרח A; ההשמה `A x = new B(...)` לא הייתה עוברת הידור (נדרשת המרה כלפי מטה, ואפילו איתה תהיה שגיאת ריצה). ירושה מעגלית (A מ-B ו-B מ-A) אסורה.

תשובה: 1 – לא נכון; 2 – לא נכון; 3 – לא נכון; 4 – לא נכון; 5 – נכון; 6 – לא נכון.

סעיף ב

תשובה:

תשובה 2: הפלט `Bye B`.

הרעיון: הפעולה a2 לא נדרסה, ולכן על עצם מסוג B מתבצעת a2 של A. בתוכה יש זימון `a1()`, כלומר `this.a1()`. כאן פועל שילוב דינמי (פולימורפיזם): הפעולה שמתבצעת נקבעת לפי הטיפוס בפועל של העצם, ולא לפי המחלקה שבה כתוב הזימון. העצם הוא מסוג B, ו-B דרסה את a1 – לכן מתבצעת a1 של B.

המחלקה B:

Java:

public class B extends A
{
    @Override
    protected void a1()
    {
        System.out.println("Bye B");
    }
}

C#:

public class B : A
{
    protected override void A1()
    {
        Console.WriteLine("Bye B");
    }
}

מהלך הביצוע של `b.a2()` (b עצם מסוג B):

1. a2 של A מתבצעת (B ירשה אותה).

2. בתוכה `a1()` – העצם הוא B, ולכן מתבצעת a1 הדורסת: מודפס `Bye B`.

3. a1 של A אינה מתבצעת כלל (הדורסת אינה קוראת ל-`super.a1()`), ולכן `Hello A` לא מודפס.

ב-C# הפעולה A1 מוגדרת `virtual`, וב-B היא נדרסת עם `override` – ולכן ההתנהגות זהה.

תשובה: תשובה 2 – הפלט יהיה `Bye B`.

שאלה 4 · ירושה, בנאים, המרות ומונים סטטיים

נתונות שתי מחלקות A ו- B:

Java:

public class A
{
    public static int countA = 0;
    private  int  myVal;
    protected String myString;
    public A() { myVal = 1;}
    public  A (int  val)   { myVal = val; myString = "GOOD!";}
    public  void  func()   { System.out.println("YES"); }
}
public class B extends A
{
    private  double  x;
    public  boolean  goodCode() { return x > 15.0; }
}

C#:

public class A
{
    public static int countA = 0;
    private  int  myVal;
    protected string myString;
    public A(){ myVal = 1; myString ="BAD";}
    public  A (int  val)   { myVal = val; myString = "GOOD!";}
    public  int  Func()   { return 1; }
}
public class B : A
{
    private  double  x;
    public  bool  GoodCode() { return x > 15.0; }
}
א.

לפניכם ארבעה היגדים. קבעו לכל אחד מהם אם הוא נכון או אינו נכון ונמקו את קביעתכם:

1. המחלקה B לא תעבור קומפילציה כי אין לה אף בנאי.

2. המחלקה A יורשת את הפעולה `goodCode` מהמחלקה B.

3. המחלקה B יורשת את כל התכונות ואת כל הפעולות של המחלקה A.

4. המחלקה B יכולה לגשת ישירות לתכונות של המחלקה A.

5. המחלקה A יכולה לגשת לתכונה x של המחלקה B.

(5 נקודות)
ב.

כתבו במחלקה B פעולה בונה שמקבלת כפרמטר מספר שלם ומספר ממשי ומאתחלת את התכונות בהתאם.

(2 נקודות)
ג.

לפניכם שתי הוראות מהתוכנית הראשית:

Java:

A one = new B(127, 1.4);
A two = new A(613);

C#:

A  one = new B(127, 1.4);
A  two = new A(613);

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

Java:

1. boolean myBool = one.goodCode();
2. boolean myBool = two.goodCode();
3. boolean myBool = ((B)one).goodCode();
4. boolean myBool = ((B)two).goodCode();

C#:

1. bool myBool = one. GoodCode ();
2. bool myBool = two. GoodCode ();
3. bool myBool = ((B) one). GoodCode ();
4. bool myBool = ((B) two). GoodCode ();
(4 נקודות)
ד.

בתוכנית מסוימת מעוניינים לדעת כמה פעמים הפעולה `func` הופעלה מעצם מטיפוס A שאינו B, וכמה פעמים היא הופעלה מעצם מטיפוס B.

אם אפשר לקבל מידע זה – כתבו איזה שינויים יש לבצע במחלקות A ו- B.

אם אי אפשר לקבל את המידע, הסבירו מדוע.

(4 נקודות)
◂ פתרון מלא לשאלה 4

סעיף א

תשובה:

1 – לא נכון; 2 – לא נכון; 3 – נכון; 4 – לא נכון; 5 – לא נכון.

1. לא נכון. כשלא כותבים אף בנאי במחלקה, המהדר מוסיף לה בנאי ברירת מחדל ללא פרמטרים, והוא מזמן את הבנאי ללא פרמטרים של מחלקת-האב (`super()` / `base()`). ל-A יש בנאי כזה (`A()`), ולכן B עוברת הידור.

2. לא נכון. הירושה היא בכיוון אחד בלבד: מחלקת-הבן יורשת מהאב. A היא האב, ואינה מכירה את הפעולות שנוספו ב-B.

3. נכון. עצם של B מכיל את כל התכונות של A (גם את `myVal` הפרטית – היא קיימת בעצם, אבל אין אליה גישה ישירה מתוך B) ואת כל הפעולות של A (`func`/`Func`). הבנאים אינם נורשים, אבל אפשר לזמן אותם מבנאי של B.

4. לא נכון. B יכולה לגשת ישירות רק לתכונות ה-public וה-protected (`countA`, `myString`). התכונה `myVal` מוגדרת private, ולכן אין אליה גישה ישירה מ-B.

5. לא נכון. x היא תכונה פרטית של B, ובנוסף A (האב) אינה מכירה תכונות שהוגדרו בבן.

תשובה: 1 – לא נכון; 2 – לא נכון; 3 – נכון; 4 – לא נכון; 5 – לא נכון.

סעיף ב

תשובה:

`public B(int val, double x) { super(val); this.x = x; }`

הרעיון: התכונה `myVal` פרטית ב-A, ולכן B אינה יכולה להציב בה ישירות. מאתחלים אותה דרך הבנאי של A שמקבל מספר שלם – זימון `super(val)` ב-Java (חייב להיות ההוראה הראשונה בבנאי) או `: base(val)` ב-C#. את התכונה `x` של B מציבים ישירות.

Java:

public B(int val, double x)
{
    super(val);     // אתחול myVal ו-myString על ידי הבנאי של A
    this.x = x;
}

C#:

public B(int val, double x) : base(val)   // אתחול myVal ו-myString על ידי הבנאי של A
{
    this.x = x;
}

תשובה: `public B(int val, double x) { super(val); this.x = x; }` (ב-C#: `: base(val)`).

סעיף ג

תשובה:

1 – שגיאת הידור; 2 – שגיאת הידור; 3 – תקינה; 4 – שגיאת ריצה.

העיקרון: המהדר בודק זימון פעולה לפי הטיפוס המוצהר של המשתנה; בזמן ריצה בודקים המרה (casting) לפי הטיפוס בפועל של העצם.

•`one` מוצהר כ-A, אבל מפנה לעצם מסוג B (עם x=1.4x=1.4).

•`two` מוצהר כ-A ומפנה לעצם מסוג A.

1. לא תקינה – שגיאת הידור. הטיפוס המוצהר של `one` הוא A, ובמחלקה A אין פעולה `goodCode`. המהדר אינו "יודע" שבפועל יש שם עצם B.

2. לא תקינה – שגיאת הידור. אותה סיבה: ל-A אין `goodCode`.

3. תקינה. ההמרה `(B)one` מתקבלת במהדר (המרה כלפי מטה מ-A ל-B), ובזמן ריצה היא מצליחה כי העצם באמת מסוג B. יוחזר `x > 15.0`, כלומר 1.4>15.01.4>15.0 – false.

4. לא תקינה – שגיאת ריצה. המהדר מקבל את ההמרה (B יורשת מ-A, ולכן ייתכן שהעצם הוא B), אבל בזמן ריצה מתברר ש-`two` מפנה לעצם מסוג A שאינו B – נזרקת חריגה (`ClassCastException` ב-Java, `InvalidCastException` ב-C#).

תשובה: 1 – שגיאת הידור; 2 – שגיאת הידור; 3 – תקינה (myBool = false); 4 – שגיאת ריצה.

סעיף ד

תשובה:

אפשר: מונה סטטי ב-A שגדל ב-func, מונה סטטי countB ב-B, ודריסת func ב-B שמעבירה את הספירה מ-countA ל-countB.

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

1. במחלקה A: בתוך `func` מגדילים את המונה הסטטי הקיים `countA` בכל זימון.

2. במחלקה B: מוסיפים מונה סטטי `countB = 0`, ודורסים את `func`: הפעולה הדורסת מזמנת את `func` של A (כדי לשמור על אותה התנהגות – הדפסת YES), ואז מתקנת את המונים: מחסירה 1 מ-`countA` (כי הזימון הזה לא היה של עצם A שאינו B) ומוסיפה 1 ל-`countB`.

3. בזכות השילוב הדינמי, גם כאשר עצם B מוחזק במשתנה מטיפוס A (כמו `one`), זימון `one.func()` מפעיל את הפעולה הדורסת של B – ולכן הספירה נכונה.

בסוף: `A.countA` = מספר הזימונים מעצמים מטיפוס A שאינם B, ו-`B.countB` = מספר הזימונים מעצמים מטיפוס B.

Java – במחלקה A:

public void func()
{
    countA++;                     // סופרים כל זימון
    System.out.println("YES");
}

Java – במחלקה B:

public static int countB = 0;

@Override
public void func()
{
    super.func();   // מבצעים את הפעולה המקורית (מדפיסה YES ומגדילה את countA)
    countA--;       // הזימון הזה אינו של עצם A "טהור"
    countB++;       // ...אלא של עצם B
}

C# – במחלקה A (ב-C# הפעולה מחזירה int, וכדי לדרוס אותה יש להגדיר אותה `virtual`):

public virtual int Func()     // הפעולה הופכת ל-virtual כדי שאפשר יהיה לדרוס אותה
{
    countA++;                 // סופרים כל זימון
    return 1;
}

C# – במחלקה B:

public static int countB = 0;

public override int Func()
{
    int result = base.Func();   // מבצעים את הפעולה המקורית (ומגדילים את countA)
    countA--;                   // הזימון הזה אינו של עצם A "טהור"
    countB++;                   // ...אלא של עצם B
    return result;
}

דוגמה: אחרי `new A().func(); one.func(); two.func(); new B().func();` יתקבל countA=2countA=2 (שני עצמי A) ו-countB=2countB=2 (שני עצמי B).

תשובה: אפשר: ב-A הפעולה func מגדילה את המונה הסטטי countA; ב-B מוסיפים מונה סטטי countB ודורסים את func כך שתזמן את func של A, תקטין את countA ב-1 ותגדיל את countB ב-1.

שאלה 5 · היררכיית מחלקות וממשקים של בעלי חיים

נתונה היררכיית המחלקות הבאה:

בממשק `IHasEggs` נמצאת כותרת הפעולה: `public void layingEggs()`

בממשק `ICanFly` נמצאת כותרת הפעולה: `public void fly()`

בכל מחלקה מוגדרת פעולה בונה ללא פרמטרים.

(במבחן ב-C#: `public void LayingEggs()` ו-`public void Fly()`.)

א.

לכל מחלקה, כתבו את כותרת המחלקה.

(5 נקודות)
ב.

עבור הפעולות הבאות קבעו אם הן חוקיות. אם הפעולה אינה חוקית, יש להסביר את הסיבה לזה.

Java:

1. Animal a=new Bat();
2. Fish f=new IHasEggs();
3. ICanFly cf=new Bird();
   cf=new Bat();
4. Mammal m=new Bat();
   m.fly();
5. Animal a=new Bird();
   ((Bird)a).fly();
6. IHasEggs he=new Bird();
   he.fly();

C#:

1. Animal a=new Bat();
2. Fish f=new IHasEggs();
3. ICanFly cf=new Bird();
   cf=new Bat();
4. Mammal m=new Bat();
   m.Fly();
5. Animal a=new Bird();
   ((Bird)a).Fly();
6. IHasEggs he=new Bird();
   he.Fly();
(6 נקודות)
ג.

כתבו פעולה המקבלת כפרמטר מערך של בעלי חיים (מערך הפניות לעצמים מסוג Animal), ומחזירה את מספר בעלי החיים המסוגלים לעוף הנמצאים במערך.

(4 נקודות)
◂ פתרון מלא לשאלה 5

סעיף א

תשובה:

Mammal, Fish, Bird יורשות מ-Animal; Bat מ-Mammal; Fish מממשת IHasEggs; Bird מממשת IHasEggs ו-ICanFly; Bat מממשת ICanFly.

קריאת התרשים: חץ רציף עם ראש מלא הוא ירושה (`extends` ב-Java, `:` ב-C#), וחץ מקווקו אל ממשק הוא מימוש (`implements`). מהתרשים:

•Mammal, Fish, Bird יורשות מ-Animal; Bat יורשת מ-Mammal.

•Fish מממשת את IHasEggs; Bird מממשת את IHasEggs ואת ICanFly; Bat מממשת את ICanFly.

•IHasEggs ו-ICanFly הם ממשקים (interface).

Java:

public interface IHasEggs
public interface ICanFly
public class Animal
public class Mammal extends Animal
public class Fish extends Animal implements IHasEggs
public class Bird extends Animal implements IHasEggs, ICanFly
public class Bat extends Mammal implements ICanFly

C#:

public interface IHasEggs
public interface ICanFly
public class Animal
public class Mammal : Animal
public class Fish : Animal, IHasEggs
public class Bird : Animal, IHasEggs, ICanFly
public class Bat : Mammal, ICanFly

ב-C# המחלקה שממנה יורשים נכתבת ראשונה אחרי הנקודתיים, ואחריה הממשקים. מחלקה יכולה לרשת ממחלקה אחת בלבד, אבל לממש כמה ממשקים (כמו Bird).

תשובה: כותרות המחלקות והממשקים שלמעלה.

סעיף ב

תשובה:

חוקיות: 1, 3, 5; לא חוקיות: 2, 4, 6.

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

1. חוקית. Bat יורשת מ-Mammal שיורשת מ-Animal, ולכן עטלף הוא בעל חיים.

2. לא חוקית. אי אפשר ליצור עצם מממשק (`new IHasEggs()`) – לממשק אין מימוש ואין בנאי. בנוסף, IHasEggs אינו Fish, ולכן גם ההשמה לא הייתה מתאימה.

3. חוקית. גם Bird וגם Bat מממשות את ICanFly, ולכן המשתנה `cf` יכול להפנות לכל אחד מהם.

4. לא חוקית (השורה השנייה). `Mammal m = new Bat()` תקינה, אבל הטיפוס המוצהר של `m` הוא Mammal, ול-Mammal אין פעולה `fly` (רק Bat מממשת את ICanFly) – שגיאת הידור.

5. חוקית. ההמרה `(Bird)a` מאפשרת לזמן את `fly` של Bird, ובזמן ריצה היא מצליחה כי `a` מפנה בפועל לעצם Bird.

6. לא חוקית (השורה השנייה). הטיפוס המוצהר הוא IHasEggs, ובממשק זה יש רק `layingEggs`; הפעולה `fly` אינה מוכרת דרכו – שגיאת הידור (אף שהעצם בפועל הוא Bird שיודע לעוף).

תשובה: חוקיות: 1, 3, 5. לא חוקיות: 2 (יצירת עצם מממשק), 4 (ל-Mammal אין fly), 6 (ל-IHasEggs אין fly).

סעיף ג

תשובה:

פעולה שסופרת את העצמים במערך שהם `instanceof ICanFly`.

הרעיון: בעל חיים "מסוגל לעוף" אם המחלקה שלו מממשת את הממשק ICanFly (בהיררכיה: Bird ו-Bat). עוברים על המערך, ולכל תא בודקים בזמן ריצה אם העצם הוא מטיפוס ICanFly – בעזרת `instanceof` ב-Java או `is` ב-C#. בדיקה מול הממשק (ולא מול Bird ו-Bat בנפרד) נכונה גם אם בעתיד יתווספו מחלקות מעופפות נוספות.

1. מונה `count = 0`.

2. לכל תא `arr[i]`: אם הוא אינו null ו-`arr[i] instanceof ICanFly` – מגדילים את המונה. (אם צריך לזמן את `fly` עבורו, ממירים: `((ICanFly) arr[i]).fly()`.)

3. מחזירים את `count`.

Java:

public static int countFlyers(Animal[] arr)
{
    int count = 0;
    for (int i = 0; i < arr.length; i++)
    {
        if (arr[i] != null && arr[i] instanceof ICanFly)   // האם העצם מסוגל לעוף?
            count++;
    }
    return count;
}

C#:

public static int CountFlyers(Animal[] arr)
{
    int count = 0;
    for (int i = 0; i < arr.Length; i++)
        if (arr[i] != null && arr[i] is ICanFly)   // האם העצם מסוגל לעוף?
            count++;
    return count;
}

דוגמה: עבור המערך {Bat, Fish, Bird, Mammal, Animal, Bird} יוחזר 3.

תשובה: הפעולה שלמעלה – סופרת את התאים שבהם `arr[i] instanceof ICanFly` (ב-C#: `is ICanFly`).

שאלה 6 · ממוצעי ציונים בשרשרת חוליות

בבית ספר "שזר" מאוכסן מידע על ציוני התלמידים במדעי המחשב כשרשרת חוליות המכילה ציונים של כל התלמידים. לכל תלמיד יש מספר שונה של ציונים. הציונים של כל תלמיד מופרדים ב- -1.

לדוגמה:

`80 -> 40 -> 90 -> -1 -> 95 -> -1 -> 85 -> 80 -> -1 -> null`

שרשרת זו מציינת ש:

•לתלמיד הראשון יש שלושה ציונים (80,40,90).

•לתלמיד השני יש ציון אחד (95).

•לתלמיד השלישי יש שני ציונים (85,80).

א.

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

עבור השרשרת הנ"ל תחזיר הפעולה את השרשרת הבאה: `70.0 -> 95.0 -> 82.5 -> null`

כותרת הפעולה:

`public static Node<Double> averageList(Node<Integer> lst)`

(במבחן ב-C#: `public static Node<double> AverageList(Node<int> lst)`)

(9 נקודות)
ב.

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

לדוגמה:

אחרי ה"שיפור" אצל התלמיד הראשון יתבטל ציון 40, אצל התלמיד השלישי יתבטל ציון 80.

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

עבור המידע הנ"ל הפעולה תדפיס:

1   70.0   85.0
2   95.0   95.0
3   82.5   85.0

כותרת הפעולה:

`public static void print(Node<Integer> lst)`

(במבחן ב-C#: `public static void Print(Node<int> lst)`)

(6 נקודות)
◂ פתרון מלא לשאלה 6

סעיף א

תשובה:

שרשרת ממוצעים: `70.0 -> 95.0 -> 82.5 -> null` (פעולה עם סכום ומונה לכל תלמיד).

הרעיון: עוברים על השרשרת פעם אחת. לכל תלמיד צוברים סכום `sum` ומונה ציונים `count`. כשמגיעים ל-−1-1 – הסתיימו ציוני התלמיד: מחשבים ממוצע ממשי, יוצרים חוליה חדשה מטיפוס Double ומוסיפים אותה בסוף השרשרת החדשה, ומאפסים את הצובר והמונה לתלמיד הבא. ה-−1-1 עצמו אינו ציון ואינו נכנס לחישוב.

1. השרשרת החדשה נבנית בסדר התלמידים, ולכן שומרים שתי הפניות: `first` (ראש, מוחזר בסוף) ו-`last` (סוף, אליו מחברים).

2. החוליה הראשונה שנוצרת הופכת ל-`first`; כל חוליה נוספת מחוברת ב-`last.setNext(node)`.

3. הממוצע: `(double) sum / count` – ההמרה ל-double מונעת חילוק שלמים (אחרת 165/2165/2 היה נותן 82 ולא 82.5).

4. לכל תלמיד יש לפחות ציון אחד, ולכן `count > 0` בזמן החילוק. שרשרת ריקה – מוחזר null.

Java:

public static Node<Double> averageList(Node<Integer> lst)
{
    Node<Double> first = null;   // ראש השרשרת החדשה
    Node<Double> last = null;    // החוליה האחרונה בשרשרת החדשה
    int sum = 0, count = 0;
    Node<Integer> p = lst;
    while (p != null)
    {
        int grade = p.getValue();
        if (grade == -1)                       // סוף הציונים של תלמיד
        {
            Node<Double> node = new Node<Double>((double) sum / count);
            if (first == null)
                first = node;
            else
                last.setNext(node);
            last = node;
            sum = 0;                           // מתחילים תלמיד חדש
            count = 0;
        }
        else
        {
            sum += grade;
            count++;
        }
        p = p.getNext();
    }
    return first;
}

C#:

public static Node<double> AverageList(Node<int> lst)
{
    Node<double> first = null;   // ראש השרשרת החדשה
    Node<double> last = null;    // החוליה האחרונה בשרשרת החדשה
    int sum = 0, count = 0;
    Node<int> p = lst;
    while (p != null)
    {
        int grade = p.GetValue();
        if (grade == -1)                       // סוף הציונים של תלמיד
        {
            Node<double> node = new Node<double>((double) sum / count);
            if (first == null)
                first = node;
            else
                last.SetNext(node);
            last = node;
            sum = 0;                           // מתחילים תלמיד חדש
            count = 0;
        }
        else
        {
            sum += grade;
            count++;
        }
        p = p.GetNext();
    }
    return first;
}

בדיקה בדוגמה:

•תלמיד 1: 80+40+903=2103=70.0\frac{80+40+90}{3}=\frac{210}{3}=70.0

•תלמיד 2: 951=95.0\frac{95}{1}=95.0

•תלמיד 3: 85+802=1652=82.5\frac{85+80}{2}=\frac{165}{2}=82.5

מוחזרת השרשרת `70.0 -> 95.0 -> 82.5 -> null`.

תשובה: הפעולה שלמעלה – צבירת סכום ומונה לכל תלמיד, ובכל −1-1 הוספת חוליה עם הממוצע לסוף שרשרת חדשה.

סעיף ב

תשובה:

פעולה שמדפיסה לכל תלמיד sum/count ו-(sum−min)/(count−1); בדוגמה 1 70.0 85.0, 2 95.0 95.0, 3 82.5 85.0.

הרעיון: כמו בסעיף א', אבל לכל תלמיד שומרים גם את הציון הנמוך ביותר `min`. ביטול הציון הנמוך פירושו: מורידים אותו מהסכום ומורידים 1 ממספר הציונים.

•ממוצע לפני: sumcount\frac{sum}{count}

•ממוצע אחרי: sum−mincount−1\frac{sum-min}{count-1} – רק אם count>1count>1; לתלמיד עם ציון אחד הממוצע לא משתנה (וכך גם נמנע חילוק באפס).

1. משתנים: `student` (מספר סידורי, מתחיל ב-1), `sum`, `count`, `min` (מאותחל לערך הגדול ביותר, כדי שכל ציון יהיה קטן ממנו).

2. לכל ציון (שאינו −1-1): מוסיפים לסכום, מגדילים מונה ומעדכנים מינימום.

3. ב-−1-1: מחשבים את שני הממוצעים, מדפיסים שורה, מקדמים את `student` ומאפסים את `sum`, `count`, `min`.

Java:

public static void print(Node<Integer> lst)
{
    int student = 1;                 // מספר סידורי של התלמיד
    int sum = 0, count = 0;
    int min = Integer.MAX_VALUE;     // הציון הנמוך ביותר של התלמיד הנוכחי
    Node<Integer> p = lst;
    while (p != null)
    {
        int grade = p.getValue();
        if (grade == -1)
        {
            double before = (double) sum / count;
            double after = before;                       // תלמיד עם ציון אחד – אין שינוי
            if (count > 1)
                after = (double) (sum - min) / (count - 1);
            System.out.println(student + " " + before + " " + after);
            student++;
            sum = 0;
            count = 0;
            min = Integer.MAX_VALUE;
        }
        else
        {
            sum += grade;
            count++;
            if (grade < min)
                min = grade;
        }
        p = p.getNext();
    }
}

C#:

public static void Print(Node<int> lst)
{
    int student = 1;                 // מספר סידורי של התלמיד
    int sum = 0, count = 0;
    int min = int.MaxValue;          // הציון הנמוך ביותר של התלמיד הנוכחי
    Node<int> p = lst;
    while (p != null)
    {
        int grade = p.GetValue();
        if (grade == -1)
        {
            double before = (double) sum / count;
            double after = before;                       // תלמיד עם ציון אחד – אין שינוי
            if (count > 1)
                after = (double) (sum - min) / (count - 1);
            Console.WriteLine(student + " " + before.ToString("0.0") + " " + after.ToString("0.0"));
            student++;
            sum = 0;
            count = 0;
            min = int.MaxValue;
        }
        else
        {
            sum += grade;
            count++;
            if (grade < min)
                min = grade;
        }
        p = p.GetNext();
    }
}

ב-C# הדפסת double עם `ToString("0.0")` מבטיחה ספרה אחת אחרי הנקודה (כמו 70.0 בדוגמה).

בדיקה בדוגמה:

תלמידציוניםלפניminאחרי
180, 40, 902103=70.0\frac{210}{3}=70.040210−402=85.0\frac{210-40}{2}=85.0
29595.095.0–95.095.0 (ציון אחד)
385, 801652=82.5\frac{165}{2}=82.580165−801=85.0\frac{165-80}{1}=85.0

הפלט: `1 70.0 85.0`, `2 95.0 95.0`, `3 82.5 85.0` – כמו בדוגמה.

תשובה: הפעולה שלמעלה – לכל תלמיד סכום, מונה ומינימום; מדפיסים sumcount\frac{sum}{count} ו-sum−mincount−1\frac{sum-min}{count-1} (או את אותו ממוצע אם יש ציון אחד).

שאלה 7 · תלת-מחסנית: מציאת מקסימום ומיון

נגדיר טיפוס נתונים חדש בשם TStack (תלת-מחסנית), כמבנה המכיל שלוש מחסניות של מספרים שלמים: S0, S1, S2.

במחלקה `TStack` הוגדרו הפעולות הבאות:

•הפעולה: `void move(int from, int to)`

הפעולה המעבירה איבר מראש מחסנית מספר from למחסנית מספר to.

לדוגמה:

move (0, 1) מעביר את האיבר הנמצא בראש המחסנית מספר 0 לראש מחסנית מספר 1.

מעברים חוקיים הם רק מ- S0 ל- S1, מ- S1 ל- S2, ומ- S2 ל- S0, כלומר, אפשר לבצע רק את מעברים הבאים:

move(0, 1);
move(1, 2);
move(2, 0);

אם הפרמטרים from ו-to אינם מקיימים מעבר חוקי, הפעולה אינה מבצעת דבר.

הנחה: המחסנית מספר from אינה ריקה.

•הפעולה: `boolean bigOrEqual(int from, int toCompare)`

היא הפעולה המחזירה true אם האיבר בראש המחסנית מספר from גדול או שווה לאיבר בראש המחסנית מספר toCompare ו- false אם המצב שונה.

הנחה: שתי המחסניות לא ריקות.

•הפעולה `boolean isEmpty(int stackId)`

היא הפעולה המחזירה `true` אם המחסנית מספר stackId ריקה ו- `false` אם המחסנית אינה ריקה.

(במבחן ב-C#: `void Move(int from, int to)`, `bool BigOrEqual(int from, int toCompare)`, `IsEmpty(int stackId)`.)

א.

נתונה תלת-מחסנית, שבה מחסנית מספר 0 מכילה מספרים שלמים לא ממוינים, ושתי מחסניות אחרות ריקות. כתבו פעולה void maximum(), המעבירה את האיבר הגדול ביותר ממחסנית S0 לראש המחסנית S1.

הערה: יש להשתמש רק בשלוש הפעולות המוגדרות במחלקה TStack! אסור להשתמש במחלקה Stack או כל מבנה אחר.

(6 נקודות)
ב.

נתונה תלת-מחסנית, שבה בכל המחסניות נמצאים מספרים שלמים לא ממוינים.

כתבו פעולה void sort(), המשנה את סדר האיברים בתלת-מחסנית, כך שבאחת מהמחסניות האיברים יהיו ממוינים בסדר עולה (האיבר הגדול ביותר נמצא בתחתית המחסנית) ושתי מחסניות האחרות תהיינה ריקות.

הערה: יש להשתמש רק בשלוש הפעולות המוגדרות במחלקה TStack ובפעולה maximum()! אסור להשתמש במחלקה Stack או בכל מבנה אחר.

(6 נקודות)
ג.

מהי סיבוכיות זמן הריצה של האלגוריתם בסעיף ב', בהנחה שבתלת-מחסנית יש N איברים?

הסיבוכיות של כל הפעולות move, bigOrEqual, isEmpty היא O(1). הסבירו את תשובתכם.

(3 נקודות)
◂ פתרון מלא לשאלה 7

סעיף א

תשובה:

S1 מחזיקה את המקסימום הנוכחי, השאר עוברים דרך S1 ל-S2 ובסוף חוזרים ל-S0.

הרעיון: S1 תשמש "תא" שמחזיק תמיד את המקסימום שנמצא עד כה – ורק אותו. S2 תשמש מחסנית עזר לכל שאר האיברים. בגלל שהמעברים חוקיים רק במעגל 0→1→2→00\to1\to2\to0, כל איבר שנפסל עובר מ-S0 ל-S2 דרך S1.

1. מעבירים את האיבר הראשון מ-S0 ל-S1 – זה המקסימום הזמני.

2. כל עוד S0 אינה ריקה, משווים את ראש S0 לראש S1 (`bigOrEqual(0, 1)`):

•אם ראש S0 גדול או שווה – המקסימום הישן מ-S1 עובר ל-S2 (`move(1, 2)`), והאיבר החדש עובר ל-S1 (`move(0, 1)`).

•אחרת – האיבר החדש קטן: מעבירים אותו ל-S1 ומיד ממנה ל-S2 (`move(0, 1)`, `move(1, 2)`). המקסימום נשאר בראש S1 מתחתיו.

בכל סיבוב איבר אחד נוסף ל-S2, וסופרים אותו במונה `k`.

3. בסוף S0 ריקה, S1 מכילה רק את האיבר הגדול ביותר, ו-S2 מכילה את כל השאר. מחזירים בדיוק kk איברים מ-S2 ל-S0 (`move(2, 0)`), כך ש-S0 שוב מכילה את שאר המספרים ו-S2 חוזרת למצבה. (החזרה של בדיוק kk איברים, ולא "עד ש-S2 ריקה", מאפשרת להשתמש בפעולה גם כש-S2 אינה ריקה מראש – וזה ינוצל בסעיף ב'.)

הפעולה משתמשת רק ב-`move`, `bigOrEqual`, `isEmpty` ובמשתנים שלמים – לא במבנה נתונים נוסף.

Java:

public void maximum()
{
    int k = 0;               // כמה איברים הועברו ל-S2
    move(0, 1);              // המועמד הראשון למקסימום עובר ל-S1
    while (!isEmpty(0))
    {
        if (bigOrEqual(0, 1))        // האיבר בראש S0 גדול או שווה למקסימום הנוכחי
        {
            move(1, 2);              // המקסימום הישן "מפנה מקום" ועובר ל-S2
            move(0, 1);              // המקסימום החדש עובר ל-S1
        }
        else                         // האיבר בראש S0 קטן מהמקסימום
        {
            move(0, 1);              // עובר דרך S1...
            move(1, 2);              // ...אל S2
        }
        k++;
    }
    for (int i = 0; i < k; i++)      // מחזירים ל-S0 בדיוק את k האיברים שהועברו
        move(2, 0);
}

C#:

public void Maximum()
{
    int k = 0;               // כמה איברים הועברו ל-S2
    Move(0, 1);              // המועמד הראשון למקסימום עובר ל-S1
    while (!IsEmpty(0))
    {
        if (BigOrEqual(0, 1))        // האיבר בראש S0 גדול או שווה למקסימום הנוכחי
        {
            Move(1, 2);              // המקסימום הישן "מפנה מקום" ועובר ל-S2
            Move(0, 1);              // המקסימום החדש עובר ל-S1
        }
        else                         // האיבר בראש S0 קטן מהמקסימום
        {
            Move(0, 1);              // עובר דרך S1...
            Move(1, 2);              // ...אל S2
        }
        k++;
    }
    for (int i = 0; i < k; i++)      // מחזירים ל-S0 בדיוק את k האיברים שהועברו
        Move(2, 0);
}

דוגמה: S0 (מהראש) = 4, 9, 1, 9, 3, 8. אחרי `maximum()`: S1 = [9], S0 מכילה את 4, 1, 9, 3, 8 (בסדר כלשהו), ו-S2 ריקה.

תשובה: הפעולה שלמעלה: S1 מחזיקה את המקסימום הנוכחי; איבר גדול-או-שווה מחליף אותו (הישן עובר ל-S2), איבר קטן עובר דרך S1 ל-S2; בסוף מחזירים את kk האיברים מ-S2 ל-S0.

סעיף ב

תשובה:

ריכוז הכול ב-S0, ואז בלולאה maximum() ו-move(1, 2); S2 ממוינת עם הגדול בתחתית.

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

1. ריכוז ב-S0: `maximum()` מניחה שכל האיברים ב-S0. מעבירים את כל S1 ל-S2 (`move(1, 2)`), ואז את כל S2 (שמכילה עכשיו את איברי S1 ו-S2 המקוריים) ל-S0 (`move(2, 0)`). כעת S1 ו-S2 ריקות.

2. סיבובי בחירה: כל עוד S0 אינה ריקה:

•`maximum()` – הגדול ביותר ב-S0 עובר לראש S1 (והוא האיבר היחיד ב-S1). במהלכה האיברים הקטנים מונחים זמנית ב-S2 מעל איברי התוצאה, ובסוף בדיוק kk מהם חוזרים ל-S0 – לכן איברי התוצאה ב-S2 אינם נפגעים.

•`move(1, 2)` – המקסימום מונח בראש S2.

3. בסוף S0 ו-S1 ריקות, ו-S2 מכילה את כל האיברים: הגדול ביותר בתחתית והקטן ביותר בראש.

Java:

public void sort()
{
    // שלב 1: מרכזים את כל האיברים ב-S0
    while (!isEmpty(1))
        move(1, 2);                  // S1 -> S2
    while (!isEmpty(2))
        move(2, 0);                  // S2 -> S0

    // שלב 2: בכל סיבוב מעבירים את הגדול מבין הנותרים ל-S2
    while (!isEmpty(0))
    {
        maximum();                   // הגדול ביותר ב-S0 עובר לראש S1 (S1 מכילה רק אותו)
        move(1, 2);                  // ומשם לראש S2, מעל איברים גדולים ממנו
    }
}

C#:

public void Sort()
{
    // שלב 1: מרכזים את כל האיברים ב-S0
    while (!IsEmpty(1))
        Move(1, 2);                  // S1 -> S2
    while (!IsEmpty(2))
        Move(2, 0);                  // S2 -> S0

    // שלב 2: בכל סיבוב מעבירים את הגדול מבין הנותרים ל-S2
    while (!IsEmpty(0))
    {
        Maximum();                   // הגדול ביותר ב-S0 עובר לראש S1 (S1 מכילה רק אותו)
        Move(1, 2);                  // ומשם לראש S2, מעל איברים גדולים ממנו
    }
}

דוגמה: S0 = 7, 1, 5 (מהראש), S1 = 6, S2 = 2. אחרי הריכוז S0 מכילה 5 מספרים. הסיבובים מעבירים ל-S2 לפי הסדר: 7, 6, 5, 2, 1. התוצאה: S2 (מהראש) = 1, 2, 5, 6, 7, ו-S0, S1 ריקות.

תשובה: הפעולה שלמעלה: ריכוז כל האיברים ב-S0, ואז שוב ושוב `maximum()` ו-`move(1, 2)` עד ש-S0 ריקה; S2 ממוינת (הגדול בתחתית).

סעיף ג

תשובה:

O(N2)O(N^2)

נספור העברות (`move`) והשוואות, שכל אחת מהן O(1)O(1).

1. ריכוז ב-S0: כל איבר עובר לכל היותר פעמיים (S1→S2→S0) – O(N)O(N).

2. זימון אחד של `maximum()` כש-S0 מכילה mm איברים: העברה ראשונה אחת; עבור כל אחד מ-m−1m-1 האיברים האחרים – השוואה אחת ושתי העברות; ובסוף m−1m-1 העברות חזרה. בסך הכול כ-3m3m צעדים – O(m)O(m).

3. הלולאה ב-`sort`: בכל סיבוב יוצא איבר אחד מ-S0, ולכן מספר האיברים ב-S0 בסיבובים הוא N,N−1,…,1N, N-1, \dots, 1. סך העבודה:

∑m=1NO(m)=O ⁣(N(N+1)2)=O(N2)\sum_{m=1}^{N} O(m) = O\!\left(\frac{N(N+1)}{2}\right) = O(N^2)

סך הכול: O(N)+O(N2)=O(N2)O(N)+O(N^2)=O(N^2).

תשובה: O(N2)O(N^2) – NN סיבובים, ובכל סיבוב `maximum()` עוברת על כל האיברים שנותרו (עבודה לינארית).

שאלה 8 · מעקב אחר פעולה רקורסיבית על עץ בינרי

נתונה הפעולה חיצונית mystery הבאה שמקבלת כפרמטר הפניה לשורש של עץ בינרי:

Java:

public static void mystery(BinNode<Character> t)
{
 if (t != null)
 {
    System.out.print (t.getValue() + " ");
    Mystery (t.getLeft());
    System.out.print (t. getValue ()+ " ");
    Mystery (t. getRight());
    System.out.print (t.getValue()+ " ");
 }
}

C#:

public static void Mystery(BinNode<char> t)
{
 if (t != null)
 {
    Console.Write (t.GetValue() + " ");
    Mystery (t.GetLeft());
    Console.Write (t. GetValue ()+ " ");
    Mystery (t. GetRight());
    Console.Write (t.GetValue()+ " ");
 }
}
א.

מה תדפיס הפעולה mystery כאשר היא תקבל את השורש של העץ הבינרי t הבא ?

חובה להראות את המעקב !

(8 נקודות)
ב.

ציירו עץ שעבורו תדפיס הפעולה mystery שורה הבאה:

`b a c c d d d c a e e f f f e a b k k k b`

(7 נקודות)
◂ פתרון מלא לשאלה 8

סעיף א

תשובה:

`a b b d d d b a c e f f f e e c c a`

מה הפעולה עושה: לכל צומת שאינו null היא מדפיסה את ערכו שלוש פעמים: לפני הירידה לתת-העץ השמאלי, בין השמאלי לימני, ואחרי הימני. עבור עלה (שני הבנים null) מודפס הערך שלוש פעמים ברצף.

(בקוד Java הזימון הרקורסיבי כתוב `Mystery` באות גדולה – שגיאת הקלדה; הכוונה לזימון רקורסיבי של `mystery`.)

העץ: a שורש; הבן השמאלי של a הוא b, והימני c. ל-b יש רק בן ימני d. ל-c יש רק בן שמאלי e, ול-e יש רק בן שמאלי f.

מעקב (העמודה "זימון" מראה את הצומת שהפעולה מטפלת בו):

צעדזימוןפעולהמודפס
1mystery(a)הדפסה ראשונהa
2mystery(b)הדפסה ראשונהb
3mystery(null)הבן השמאלי של b – לא קורה דבר
4mystery(b)הדפסה שנייהb
5mystery(d)עלה: הדפסה ראשונה, שמאל null, הדפסה שנייה, ימין null, הדפסה שלישיתd d d
6mystery(b)הדפסה שלישית, חזרה ל-ab
7mystery(a)הדפסה שנייהa
8mystery(c)הדפסה ראשונהc
9mystery(e)הדפסה ראשונהe
10mystery(f)עלהf f f
11mystery(e)הדפסה שנייה; הבן הימני null; הדפסה שלישיתe e
12mystery(c)הדפסה שנייה; הבן הימני null; הדפסה שלישיתc c
13mystery(a)הדפסה שלישיתa

תשובה: יודפס: `a b b d d d b a c e f f f e e c c a`

סעיף ב

תשובה:

שורש b; ל-b בן שמאלי a ובן ימני k; ל-a בנים c (שמאל) ו-e (ימין); ל-c בן ימני d; ל-e בן ימני f.

הרעיון: הפלט של `mystery` על עץ שאינו ריק בנוי כך:

root    [left]    root    [right]    root\text{root} \;\; [\text{left}] \;\; \text{root} \;\; [\text{right}] \;\; \text{root}

כאשר [left] ו-[right] הם הפלטים של תתי-העצים (ריקים אם הבן null). לכן התו הראשון והתו האחרון הם השורש, ובמחרוזת שביניהם מופיע השורש פעם נוספת בדיוק במקום שבו נגמר תת-העץ השמאלי. בתוך הפלט של תת-עץ כל צומת מופיע 3 פעמים, ולכן כל פלט של תת-עץ מתחיל ונגמר באותו תו. מפרקים מבחוץ פנימה.

1. הפלט: `b a c c d d d c a e e f f f e a b k k k b` (21 תווים = 7 צמתים × 3). התו הראשון והאחרון הם b – השורש b.

2. בין שני ה-b החיצוניים: `a c c d d d c a e e f f f e a` `b` `k k k`. תת-העץ השמאלי מתחיל ב-a ונגמר ב-a (15 תווים = 5 צמתים), אחריו ה-b האמצעי, ותת-העץ הימני `k k k` – עלה k (בן ימני של b).

3. תת-העץ של a: `a` [`c c d d d c`] `a` [`e e f f f e`] `a` – הבן השמאלי של a הוא c, והימני e.

4. תת-העץ של c: `c` [ ] `c` [`d d d`] `c` – אין בן שמאלי (ה-c השני מגיע מיד), והבן הימני הוא העלה d.

5. תת-העץ של e: `e` [ ] `e` [`f f f`] `e` – אין בן שמאלי, והבן הימני הוא העלה f.

העץ:

          b
        /   \
       a     k
      / \
     c   e
      \   \
       d   f

•שורש b: בן שמאלי a, בן ימני k (עלה).

•a: בן שמאלי c, בן ימני e.

•c: אין בן שמאלי, בן ימני d (עלה).

•e: אין בן שמאלי, בן ימני f (עלה).

בדיקה: הפעלת `mystery` על העץ הזה נותנת `b` + (`a` + `c c d d d c` + `a` + `e e f f f e` + `a`) + `b` + `k k k` + `b` – בדיוק השורה הנתונה.

תשובה: שורש b; בן שמאלי a ובן ימני k; ל-a בן שמאלי c ובן ימני e; ל-c בן ימני d; ל-e בן ימני f.

שאלה 9 · תכנון מחלקות למערכת תשלומים בחנות

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

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

לדוגמה:

לפניכם כמה שילובים אפשריים של אמצעי תשלום בעבור קניה בסכום של 1000 ש"ח.

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

•לשלם 200 ₪ במזומן ו-800 ₪ בכרטיס אשראי ב- 4 תשלומים שווים (כל חודש יחויב סכום של 200 ₪).

•לשלם 100 ₪ במזומן, 500 ₪ באמצעות שתי המחאות: הראשונה על סך 200 ₪ והשנייה על סך 300 ₪, ו- 400 ₪ בכרטיס אשראי.

החנות זקוקה לתוכנה כדי לנהל את תשלומי הקונים.

בעבור כל קנייה, המידע המתקבל בחנות הוא:

תאריך הקניה, הסכום לתשלום בעבור הקנייה, פירוט שילוב אמצעי התשלום ומספר אמצעי התשלום שבאמצעותם נערכה הקנייה.

בעבור תשלום במזומן – הסכום לתשלום.

בעבור תשלום בהמחאה – הסכום לתשלום, מספר ההמחאה, שם הבנק והתאריך הרשום על ההמחאה.

בעבור תשלום בכרטיס אשראי – הסכום לתשלום, מספר כרטיס האשראי, תוקף הכרטיס והתאריך שבו יחויב בעל כרטיס האשראי.

בחנות יישמר המידע עבור הקניות שנעשו בחנות ומספר הקניות שבוצעו.

הפעולות הנפוצות בניהול מערכת תשלומים:

•בדיקה שסכום כל התשלומים בעבור קנייה אחת שווה לסכום הקנייה.

•הדפסת פרטי הקניות שהתשלום עבורן התבצע בכרטיס אשראי מסוים (לפחות אחד התשלומים)

•דיווח של מספר הקניות שבוצעו במזומן בלבד.

כדי לנהל מערכת תשלומים מפתחים פרויקט הכולל את המחלקות הבאות:

•Store – המייצגת את החנות.

•Buy – המייצגת קניה.

•Payment – המייצגת תשלום.

•Cash – המייצגת תשלום במזומן.

•Credit – המייצגת תשלום בכרטיס אשראי.

•Cheque – המייצגת תשלום בהמחאה.

לפניכם תרשים של היררכיית המחלקות הנדרשות בעבור כתיבת התוכנה.

א.

כתבו את כותרות המחלקות הנזכרות בתרשים ולכל מחלקה הוסיפו את התכונות הנדרשות. הוסיפו תיעוד!

אפשר להניח שקיימת מחלקה Date, המייצגת תאריך.

(6 נקודות)
ב.

כתבו את הפעולות הנזכרות לעיל וציינו באיזו מחלקה צריכה להיות כל פעולה:

1. בדיקה שסכום כל התשלומים בעבור קנייה אחת שווה לסכום הקנייה.

`public boolean check()`

2. פעולה המקבלת מספר כרטיס אשראי ומדפיסה את פרטי הקניות שהיה בהן תשלום בכרטיס אשראי זה (לפחות אחד התשלומים).

`public void print (String creditNum)`

3. פעולה המחזירה את מספר הקניות שבוצעו במזומן בלבד.

`public int cashPayments()`

(במבחן ב-C#: `public bool Check()`, `public void Print (string creditNum)`, `public int CashPayments()`.)

הערות:

•אפשר להניח כי בכל מחלקה הוגדרו פעולות get/set ו- toString (אין צורך לממש).

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

(6 נקודות)
◂ פתרון מלא לשאלה 9

סעיף א

תשובה:

Payment (מופשטת, amount) ויורשות Cash, Cheque, Credit עם תכונותיהן; Buy: date, sum, Payment[] ומונה; Store: Buy[] ומונה.

קריאת התרשים:

•ירושה: Cash, Credit, Cheque יורשות מ-Payment. המשותף לכל אמצעי התשלום – הסכום – נשמר פעם אחת במחלקת הבסיס Payment, וכל מחלקה יורשת מוסיפה רק את הפרטים המיוחדים לה. Payment מוגדרת מופשטת (abstract), כי כל תשלום בפועל הוא אחד משלושת הסוגים.

•הכלה: Store מכילה קניות (מערך של Buy ומונה), ו-Buy מכילה תשלומים (מערך של Payment ומונה). מערך מטיפוס Payment יכול להחזיק עצמים מכל אחד משלושת הסוגים (פולימורפיזם) – וכך נשמר "פירוט שילוב אמצעי התשלום".

התכונות לפי המידע שבשאלה:

מחלקהתכונות
Paymentamount – הסכום לתשלום
Cash(אין תכונות נוספות – רק הסכום)
ChequechequeNum – מספר ההמחאה, bank – שם הבנק, date – התאריך הרשום על ההמחאה
CreditcardNum – מספר הכרטיס, validity – תוקף הכרטיס, chargeDate – תאריך החיוב
Buydate – תאריך הקנייה, sum – הסכום לתשלום, payments – מערך התשלומים, numPayments – מספר אמצעי התשלום
Storebuys – מערך הקניות, numBuys – מספר הקניות שבוצעו

תשלום בהמחאות או באשראי שמחולק לכמה תשלומים נשמר ככמה עצמים (למשל ארבעה עצמי Credit של 200 ₪, כל אחד עם תאריך החיוב שלו). מספר כרטיס האשראי נשמר כמחרוזת (הוא ארוך מדי ל-int). הוספנו גם בנאים ופעולות הוספה (`addPayment`, `addBuy`), ופעולות get שבהן נשתמש בסעיף ב'.

Java:

// תשלום כללי – מחלקת בסיס לכל אמצעי התשלום
public abstract class Payment
{
    protected double amount;     // הסכום ששולם באמצעי תשלום זה

    public Payment(double amount)
    {
        this.amount = amount;
    }

    public double getAmount()
    {
        return this.amount;
    }
}

// תשלום במזומן – רק הסכום (נשמר במחלקת הבסיס)
public class Cash extends Payment
{
    public Cash(double amount)
    {
        super(amount);
    }
}

// תשלום בהמחאה
public class Cheque extends Payment
{
    private int chequeNum;       // מספר ההמחאה
    private String bank;         // שם הבנק
    private Date date;           // התאריך הרשום על ההמחאה

    public Cheque(double amount, int chequeNum, String bank, Date date)
    {
        super(amount);
        this.chequeNum = chequeNum;
        this.bank = bank;
        this.date = date;
    }
}

// תשלום בכרטיס אשראי
public class Credit extends Payment
{
    private String cardNum;      // מספר כרטיס האשראי
    private Date validity;       // תוקף הכרטיס
    private Date chargeDate;     // התאריך שבו יחויב בעל הכרטיס

    public Credit(double amount, String cardNum, Date validity, Date chargeDate)
    {
        super(amount);
        this.cardNum = cardNum;
        this.validity = validity;
        this.chargeDate = chargeDate;
    }

    public String getCardNum()
    {
        return this.cardNum;
    }
}

// קנייה אחת בחנות
public class Buy
{
    private Date date;            // תאריך הקנייה
    private double sum;           // הסכום לתשלום עבור הקנייה
    private Payment[] payments;   // פירוט אמצעי התשלום (מזומן / המחאה / אשראי)
    private int numPayments;      // מספר אמצעי התשלום שבאמצעותם נערכה הקנייה

    public Buy(Date date, double sum, int maxPayments)
    {
        this.date = date;
        this.sum = sum;
        this.payments = new Payment[maxPayments];
        this.numPayments = 0;
    }

    public void addPayment(Payment p)
    {
        if (this.numPayments < this.payments.length)
        {
            this.payments[this.numPayments] = p;
            this.numPayments++;
        }
    }
}

// החנות
public class Store
{
    private Buy[] buys;           // הקניות שנעשו בחנות
    private int numBuys;          // מספר הקניות שבוצעו

    public Store(int maxBuys)
    {
        this.buys = new Buy[maxBuys];
        this.numBuys = 0;
    }

    public void addBuy(Buy b)
    {
        if (this.numBuys < this.buys.length)
        {
            this.buys[this.numBuys] = b;
            this.numBuys++;
        }
    }
}

C#:

// תשלום כללי – מחלקת בסיס לכל אמצעי התשלום
public abstract class Payment
{
    protected double amount;     // הסכום ששולם באמצעי תשלום זה

    public Payment(double amount)
    {
        this.amount = amount;
    }

    public double GetAmount()
    {
        return this.amount;
    }
}

// תשלום במזומן – רק הסכום (נשמר במחלקת הבסיס)
public class Cash : Payment
{
    public Cash(double amount) : base(amount)
    {
    }
}

// תשלום בהמחאה
public class Cheque : Payment
{
    private int chequeNum;       // מספר ההמחאה
    private string bank;         // שם הבנק
    private Date date;           // התאריך הרשום על ההמחאה

    public Cheque(double amount, int chequeNum, string bank, Date date) : base(amount)
    {
        this.chequeNum = chequeNum;
        this.bank = bank;
        this.date = date;
    }
}

// תשלום בכרטיס אשראי
public class Credit : Payment
{
    private string cardNum;      // מספר כרטיס האשראי
    private Date validity;       // תוקף הכרטיס
    private Date chargeDate;     // התאריך שבו יחויב בעל הכרטיס

    public Credit(double amount, string cardNum, Date validity, Date chargeDate) : base(amount)
    {
        this.cardNum = cardNum;
        this.validity = validity;
        this.chargeDate = chargeDate;
    }

    public string GetCardNum()
    {
        return this.cardNum;
    }
}

// קנייה אחת בחנות
public class Buy
{
    private Date date;            // תאריך הקנייה
    private double sum;           // הסכום לתשלום עבור הקנייה
    private Payment[] payments;   // פירוט אמצעי התשלום (מזומן / המחאה / אשראי)
    private int numPayments;      // מספר אמצעי התשלום שבאמצעותם נערכה הקנייה

    public Buy(Date date, double sum, int maxPayments)
    {
        this.date = date;
        this.sum = sum;
        this.payments = new Payment[maxPayments];
        this.numPayments = 0;
    }

    public void AddPayment(Payment p)
    {
        if (this.numPayments < this.payments.Length)
        {
            this.payments[this.numPayments] = p;
            this.numPayments++;
        }
    }
}

// החנות
public class Store
{
    private Buy[] buys;           // הקניות שנעשו בחנות
    private int numBuys;          // מספר הקניות שבוצעו

    public Store(int maxBuys)
    {
        this.buys = new Buy[maxBuys];
        this.numBuys = 0;
    }

    public void AddBuy(Buy b)
    {
        if (this.numBuys < this.buys.Length)
        {
            this.buys[this.numBuys] = b;
            this.numBuys++;
        }
    }
}

תשובה: Payment (מופשטת, amount); Cash, Cheque, Credit יורשות ממנה (Cheque: מספר, בנק, תאריך; Credit: מספר כרטיס, תוקף, תאריך חיוב); Buy: תאריך, סכום, מערך Payment ומונה; Store: מערך Buy ומונה.

סעיף ב

תשובה:

check ב-Buy; print ו-cashPayments ב-Store (עם פעולות העזר paidWithCard ו-onlyCash ב-Buy).

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

1. `check` – במחלקה Buy: היא בודקת קנייה אחת, ורק ל-Buy יש את סכום הקנייה ואת מערך התשלומים שלה.

2. `print` – במחלקה Store: צריך לעבור על כל הקניות בחנות. את הבדיקה של קנייה אחת ("האם שולמה בכרטיס זה?") מעבירים לפעולת עזר `paidWithCard` במחלקה Buy.

3. `cashPayments` – במחלקה Store: סופרת קניות בחנות, בעזרת פעולת העזר `onlyCash` במחלקה Buy.

פירוט:

1. check: צוברים את `getAmount()` של כל התשלומים (פולימורפיזם – כל סוג תשלום יורש את `getAmount` מ-Payment), ומשווים לסכום הקנייה. כי הסכומים ממשיים, משווים עם סבולת קטנה ולא עם `==`.

2. paidWithCard: עוברים על התשלומים; תשלום מתאים הוא עצם מסוג Credit (`instanceof` / `is`) שמספר הכרטיס שלו שווה ל-`creditNum` – ההשוואה רק אחרי המרה ל-Credit, כי רק לו יש `getCardNum`. מחרוזות ב-Java משווים עם `equals`.

print: לכל קנייה שעבורה `paidWithCard` מחזירה true – מדפיסים את פרטיה (ה-toString של Buy, שמותר להניח שקיים).

3. onlyCash: קנייה שולמה "במזומן בלבד" אם יש בה לפחות תשלום אחד וכל התשלומים מסוג Cash; תשלום אחד שאינו Cash מספיק כדי להחזיר false.

cashPayments: סופרים את הקניות שעבורן `onlyCash` מחזירה true.

Java:

// במחלקה Buy
public boolean check()
{
    double total = 0;
    for (int i = 0; i < this.numPayments; i++)
        total += this.payments[i].getAmount();
    return Math.abs(total - this.sum) < 0.001;   // השוואת ממשיים עם סבולת עיגול
}

// פעולת עזר במחלקה Buy: האם אחד התשלומים בוצע בכרטיס creditNum
public boolean paidWithCard(String creditNum)
{
    for (int i = 0; i < this.numPayments; i++)
        if (this.payments[i] instanceof Credit &&
            ((Credit) this.payments[i]).getCardNum().equals(creditNum))
            return true;
    return false;
}

// פעולת עזר במחלקה Buy: האם כל התשלומים בוצעו במזומן
public boolean onlyCash()
{
    if (this.numPayments == 0)
        return false;
    for (int i = 0; i < this.numPayments; i++)
        if (!(this.payments[i] instanceof Cash))
            return false;
    return true;
}

// במחלקה Store
public void print(String creditNum)
{
    for (int i = 0; i < this.numBuys; i++)
        if (this.buys[i].paidWithCard(creditNum))
            System.out.println(this.buys[i]);     // toString של Buy
}

// במחלקה Store
public int cashPayments()
{
    int count = 0;
    for (int i = 0; i < this.numBuys; i++)
        if (this.buys[i].onlyCash())
            count++;
    return count;
}

C#:

// במחלקה Buy
public bool Check()
{
    double total = 0;
    for (int i = 0; i < this.numPayments; i++)
        total += this.payments[i].GetAmount();
    return Math.Abs(total - this.sum) < 0.001;   // השוואת ממשיים עם סבולת עיגול
}

// פעולת עזר במחלקה Buy: האם אחד התשלומים בוצע בכרטיס creditNum
public bool PaidWithCard(string creditNum)
{
    for (int i = 0; i < this.numPayments; i++)
        if (this.payments[i] is Credit &&
            ((Credit) this.payments[i]).GetCardNum() == creditNum)
            return true;
    return false;
}

// פעולת עזר במחלקה Buy: האם כל התשלומים בוצעו במזומן
public bool OnlyCash()
{
    if (this.numPayments == 0)
        return false;
    for (int i = 0; i < this.numPayments; i++)
        if (!(this.payments[i] is Cash))
            return false;
    return true;
}

// במחלקה Store
public void Print(string creditNum)
{
    for (int i = 0; i < this.numBuys; i++)
        if (this.buys[i].PaidWithCard(creditNum))
            Console.WriteLine(this.buys[i]);     // ToString של Buy
}

// במחלקה Store
public int CashPayments()
{
    int count = 0;
    for (int i = 0; i < this.numBuys; i++)
        if (this.buys[i].OnlyCash())
            count++;
    return count;
}

דוגמה: בחנות שלוש הקניות מהדוגמה בשאלה (כל אחת 1000 ₪) וקנייה רביעית בסך 500 ₪ ששולמה ב-100 + 300 ₪ במזומן. `check` מחזירה true לשלוש הראשונות ו-false לרביעית (400≠500400\ne500). `cashPayments` מחזירה 2 (הקנייה הראשונה, אם שולמה כולה במזומן, והרביעית).

תשובה: check במחלקה Buy; print ו-cashPayments במחלקה Store, עם פעולות העזר paidWithCard ו-onlyCash במחלקה Buy (הקוד שלמעלה).

שאלה 10 · ניהול פרסומות ברדיו לפי שעות שידור

פרסומת ברדיו מאופיינת במשך זמן הפרסומת בשניות `length`, בשם המוצר המפורסם `product`, בשם החברה המפרסמת `company` ובמחיר הפרסומת `price`.

המחלקה `Advert` כוללת את התכונות הבאות:

Java:

public class Advert
{
  private int length;
  private String product;
  private String company;
  private double price;

C#:

public class Advert
{
  private int length;
  private string product;
  private string company;
  private double price;

במחלקה הוגדרו פעולה בונה (בנאי- constructor), פעולות set/get לכל התכונות

בשעת שידור אחת מותר לפרסם מקסימום 15 פרסומות במשך חמש דקות בסה"כ. מספר הפרסומות המדויק בשעת השידור לא ידוע מראש, מכיוון שהוא תלוי באורכן של הפרסומות המשודרות באותה שעה.

שעות שידור הן מספרים שלמים: 0,1,2...23.

המחלקה שעת שידור, AdvertHour, מכילה את הפרסומות המשודרות בשעה מסוימת.

חלק מפעולות הממשק של המחלקה AdvertHour מתוארות בטבלה הבאה:

שם הפעולהתיאור הפעולה
freeTimeהפעולה מחזירה את הזמן (בשניות) שנותר פנוי לפרסומת בשעת השידור.
isPossibleהפעולה מקבלת פרסומת adv ומחזירה אמת אם אפשר להוסיף את הפרסומת לשעת השידור.
addAdvertהפעולה מקבלת פרסומת adv ומוסיפה אותה לשעת השידור. הפרסומת adv תהיה פרסומת האחרונה שתשודר. אם אי אפשר להוסיף פרסומת, הפעולה לא מבצעת דבר.

(במבחן ב-C#: FreeTime, IsPossible, AddAdvert.)

א.

כתבו את כותרת המחלקה AdvertHour ואת התכונות שלה.

חובה לתעד את התכונות.

(1 נקודות)
ב.

כתבו את הבנאי של המחלקה ואת שלוש הפעולות freeTime, isPossible, addAdvert.

(6 נקודות)

המחלקה ManageDay מנהלת את יום השידור תוך שימוש במחלקות AdvertHour ו- Advert.

ג.

כתבו את כותרת המחלקה ManageDay ואת התכונות שלה.

חובה לתעד את התכונות.

(1 נקודות)
ד.

כתבו פעולה benefitDay במחלקה ManageDay המחזירה את הרווח הכולל שהתקבל משידור הפרסומות ביום זה.

(4 נקודות)
◂ פתרון מלא לשאלה 10

סעיף א

תשובה:

AdvertHour: MAX_ADVERTS = 15, MAX_TIME = 300, hour, Advert[] adverts, numAdverts.

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

•קבועים: `MAX_ADVERTS = 15` (מספר פרסומות מרבי) ו-`MAX_TIME = 300` – חמש דקות הן 5⋅60=3005\cdot60=300 שניות, באותה יחידה של `length`.

•`hour` – שעת השידור (0 עד 23).

•`adverts` – מערך הפרסומות, לפי סדר השידור (הפרסומת האחרונה במערך משודרת אחרונה).

•`numAdverts` – כמה תאים במערך תפוסים.

Java:

public class AdvertHour
{
    public static final int MAX_ADVERTS = 15;   // מספר הפרסומות המרבי בשעת שידור
    public static final int MAX_TIME = 300;     // זמן הפרסום המרבי בשעה: 5 דקות = 300 שניות

    private int hour;            // שעת השידור (0 עד 23)
    private Advert[] adverts;    // הפרסומות המשודרות בשעה זו, לפי סדר השידור
    private int numAdverts;      // מספר הפרסומות שכבר נקבעו לשעה זו

C#:

public class AdvertHour
{
    public const int MAX_ADVERTS = 15;   // מספר הפרסומות המרבי בשעת שידור
    public const int MAX_TIME = 300;     // זמן הפרסום המרבי בשעה: 5 דקות = 300 שניות

    private int hour;            // שעת השידור (0 עד 23)
    private Advert[] adverts;    // הפרסומות המשודרות בשעה זו, לפי סדר השידור
    private int numAdverts;      // מספר הפרסומות שכבר נקבעו לשעה זו

תשובה: `public class AdvertHour` עם הקבועים MAX_ADVERTS = 15, MAX_TIME = 300 והתכונות hour, Advert[] adverts, numAdverts.

סעיף ב

תשובה:

בנאי; freeTime = 300 − סכום האורכים; isPossible: פחות מ-15 וגם length ≤ freeTime; addAdvert מוסיפה בסוף אם isPossible.

1. בנאי: מקבל את שעת השידור, יוצר מערך ריק בגודל 15 ומאפס את המונה.

2. freeTime: סוכמים את אורכי הפרסומות שכבר נקבעו, ומחזירים 300−used300-\text{used} שניות.

3. isPossible: אפשר להוסיף פרסומת רק אם שני התנאים מתקיימים: עדיין יש פחות מ-15 פרסומות, וגם אורך הפרסומת אינו גדול מהזמן הפנוי.

4. addAdvert: אם `isPossible(adv)` – מכניסים את הפרסומת לתא הפנוי הבא (`adverts[numAdverts]`), כך שהיא האחרונה בסדר השידור, ומגדילים את המונה. אחרת – לא עושים דבר.

Java:

public AdvertHour(int hour)
{
    this.hour = hour;
    this.adverts = new Advert[MAX_ADVERTS];
    this.numAdverts = 0;
}

public int freeTime()
{
    int used = 0;                                  // סך השניות שכבר תפוסות
    for (int i = 0; i < this.numAdverts; i++)
        used += this.adverts[i].getLength();
    return MAX_TIME - used;
}

public boolean isPossible(Advert adv)
{
    return this.numAdverts < MAX_ADVERTS && adv.getLength() <= this.freeTime();
}

public void addAdvert(Advert adv)
{
    if (this.isPossible(adv))
    {
        this.adverts[this.numAdverts] = adv;      // נכנסת אחרי האחרונה – תשודר אחרונה
        this.numAdverts++;
    }
}

C#:

public AdvertHour(int hour)
{
    this.hour = hour;
    this.adverts = new Advert[MAX_ADVERTS];
    this.numAdverts = 0;
}

public int FreeTime()
{
    int used = 0;                                  // סך השניות שכבר תפוסות
    for (int i = 0; i < this.numAdverts; i++)
        used += this.adverts[i].GetLength();
    return MAX_TIME - used;
}

public bool IsPossible(Advert adv)
{
    return this.numAdverts < MAX_ADVERTS && adv.GetLength() <= this.FreeTime();
}

public void AddAdvert(Advert adv)
{
    if (this.IsPossible(adv))
    {
        this.adverts[this.numAdverts] = adv;      // נכנסת אחרי האחרונה – תשודר אחרונה
        this.numAdverts++;
    }
}

דוגמה: אם בשעה נקבעו 10 פרסומות של 30 שניות, `freeTime()` מחזירה 300−10⋅30=0300-10\cdot30=0, ופרסומת נוספת לא תתווסף. אם נקבעו 15 פרסומות של 10 שניות, הזמן הפנוי הוא 300−150=150300-150=150 שניות, אבל `isPossible` מחזירה false כי כבר יש 15 פרסומות.

תשובה: הבנאי והפעולות שלמעלה: freeTime = 300 פחות סכום האורכים; isPossible – פחות מ-15 פרסומות וגם האורך ≤ הזמן הפנוי; addAdvert מוסיפה בסוף המערך רק אם isPossible.

סעיף ג

תשובה:

ManageDay: HOURS = 24, AdvertHour[] hours (תא i – שעה i).

יום השידור מורכב מ-24 שעות שידור (0 עד 23), ולכל אחת עצם AdvertHour. מתאים מערך בגודל 24 שבו התא ii הוא שעת השידור ii – כך מגיעים ישירות לשעה לפי מספרה. (הוספנו גם בנאי שיוצר את 24 השעות.)

Java:

public class ManageDay
{
    public static final int HOURS = 24;   // מספר שעות השידור ביום (0 עד 23)

    private AdvertHour[] hours;           // hours[i] – הפרסומות של שעת השידור i

    public ManageDay()
    {
        this.hours = new AdvertHour[HOURS];
        for (int i = 0; i < HOURS; i++)
            this.hours[i] = new AdvertHour(i);
    }

C#:

public class ManageDay
{
    public const int HOURS = 24;          // מספר שעות השידור ביום (0 עד 23)

    private AdvertHour[] hours;           // hours[i] – הפרסומות של שעת השידור i

    public ManageDay()
    {
        this.hours = new AdvertHour[HOURS];
        for (int i = 0; i < HOURS; i++)
            this.hours[i] = new AdvertHour(i);
    }

תשובה: `public class ManageDay` עם הקבוע HOURS = 24 והתכונה `AdvertHour[] hours` (תא ii – שעת השידור ii).

סעיף ד

תשובה:

סכום hourIncome() על 24 השעות (פעולת עזר ב-AdvertHour שסוכמת את מחירי הפרסומות).

הרעיון: הרווח היומי הוא סכום המחירים של כל הפרסומות בכל 24 השעות. המחלקה ManageDay אינה ניגשת ישירות למערך הפרטי של AdvertHour, ולכן מוסיפים ל-AdvertHour פעולת עזר `hourIncome` שמחזירה את סכום המחירים בשעה אחת, ו-`benefitDay` סוכמת אותה על כל השעות.

1. hourIncome (במחלקה AdvertHour): סכום `getPrice()` של `numAdverts` הפרסומות.

2. benefitDay (במחלקה ManageDay): לולאה על 24 השעות וצבירת `hours[i].hourIncome()`.

Java:

// פעולת עזר במחלקה AdvertHour: סך המחירים של הפרסומות בשעה זו
public double hourIncome()
{
    double total = 0;
    for (int i = 0; i < this.numAdverts; i++)
        total += this.adverts[i].getPrice();
    return total;
}

// במחלקה ManageDay
public double benefitDay()
{
    double total = 0;
    for (int i = 0; i < HOURS; i++)
        total += this.hours[i].hourIncome();
    return total;
}

C#:

// פעולת עזר במחלקה AdvertHour: סך המחירים של הפרסומות בשעה זו
public double HourIncome()
{
    double total = 0;
    for (int i = 0; i < this.numAdverts; i++)
        total += this.adverts[i].GetPrice();
    return total;
}

// במחלקה ManageDay
public double BenefitDay()
{
    double total = 0;
    for (int i = 0; i < HOURS; i++)
        total += this.hours[i].HourIncome();
    return total;
}

דוגמה: אם בשעה 8 שודרו 10 פרסומות במחיר 100 כל אחת, ובשעה 9 שודרו 15 פרסומות במחיר 50.5, ובשאר השעות לא שודרו פרסומות, יוחזר 10⋅100+15⋅50.5=1000+757.5=1757.510\cdot100+15\cdot50.5=1000+757.5=1757.5.

תשובה: benefitDay סוכמת על 24 השעות את hourIncome() – פעולת עזר ב-AdvertHour שמחזירה את סכום מחירי הפרסומות באותה שעה.

שאלה 11 · ירושה, הכלה ומעקב אחר מיכל עצמים

נתונות שלוש המחלקות `Basis`, `SingleOne`, `MultiOne`:

Java:

class Basis    {
    protected int num1;
    public Basis()
    {
    }
    public Basis(int n)
    {
        this.num1 = n;
    }
    public void print()
    {
        System.out.println(this.num1);
    }
}
class SingleOne extended Basis    {
    protected int num2;
    public SingleOne(int n1, int n2)
    {
        super(n1);
        this.num2 = n2;
    }
    public void print()
    {
        super.print();
        System.out.println(this.num2);
    }
}
class MultiOne extends Basis    {
    private int count = 0;
    private Basis[] arr;
    public MultiOne()
    {
        this.arr = new Basis[5];
    }
    public void print()
    {
        for (int i = 0; i < count; i++)
            arr[i].print();
    }
    public void add(Basis b) {
        if(cout<arr.length)
         {
          arr[count] = b;
          count++;
    }
}

C#:

class Basis     {
    protected int num1;
    public Basis()
    {
    }
    public Basis(int n)
    {
        this.num1 = n;
    }
    public virtual void Print()
    {
        Console.WriteLine(this.num1);
    }
}
class SingleOne:Basis    {
    protected int num2;
    public SingleOne(int n1, int n2):base(n1)
    {
        this.num2 = n2;
    }
    public override void Print()
    {
        base.Print();
        Console.WriteLine(this.num2);
    }
}
class MultiOne : Basis     {
    private int count = 0;
    private Basis[] arr;
    public MultiOne()
    {
        this.arr = new Basis[5];
    }
    public override void Print()
    {
        for (int i = 0; i < count; i++)
             arr[i].Print();
    }
    public void Add(Basis b)
    {
        if(count<arr.Length)
           {
             arr[count] = b;
             count++;
           }
    }
}
א.

ציירו תרשים UML שמייצג את הקשרים בין המחלקות Basis, SingleOne, MultiOne.

יש לסמן ירושה באמצעות החץ ——▶ והכלה באמצעות הסימן ◆——

(2 נקודות)
ב.

נתונה המחלקה Test ובה הפעולה הראשית.

עקבו בעזרת טבלת מעקב אחר הפעולה Main במחלקה Test, ורשמו את הפלט.

על הטבלה לכלול את ערכי כל המשתנים, ובעבור כל עצם – את ערכי התכונות שלו.

Java:

class Test
{
    public static void Main(String[] args)
    {
        MultiOne container = new MultiOne();
        SingleOne s1 = new SingleOne(11, 35);
        container.add(s1);
        s1 = new SingleOne(47, 22);
        container.add(s1);
        s1 = new SingleOne(8, 17);
        container.add(s1);
        MultiOne subContainer = new MultiOne();
        s1 = new SingleOne(53, 40);
        subContainer.add(s1);
        s1 = new SingleOne(21, 13);
        subContainer.add(s1);
        s1 = new SingleOne(39, 62);
        subContainer.add(s1);
        container.add(subContainer);
        container.print();
    }

C#:

class Test
{
    public static void Main(string[] args)
    {
        MultiOne container = new MultiOne();
        SingleOne s1 = new SingleOne(11, 35);
        container.Add(s1);
        s1 = new SingleOne(47, 22);
        container.Add(s1);
        s1 = new SingleOne(8, 17);
        container.Add(s1);
        MultiOne subContainer = new MultiOne();
        s1 = new SingleOne(53, 40);
        subContainer.Add(s1);
        s1 = new SingleOne(21, 13);
        subContainer.Add(s1);
        s1 = new SingleOne(39, 62);
        subContainer.Add(s1);
        container.Add(subContainer);
        container.Print();
    }
}
(10 נקודות)
◂ פתרון מלא לשאלה 11

סעיף א

תשובה:

SingleOne ו-MultiOne יורשות מ-Basis; MultiOne מכילה Basis (המעוין בצד MultiOne).

הקשרים בין המחלקות:

1. `SingleOne extends Basis` – ירושה: חץ מ-SingleOne אל Basis.

2. `MultiOne extends Basis` – ירושה: חץ מ-MultiOne אל Basis.

3. ב-MultiOne יש תכונה `Basis[] arr` – MultiOne מכילה עצמים מסוג Basis: קו הכלה בין MultiOne ל-Basis, והמעוין בצד של MultiOne (המחלקה המכילה).

התרשים:

   +-----------+          +-------+          +----------+
   | SingleOne |--------->| Basis |<---------| MultiOne |
   +-----------+          +-------+          +----------+
                              |                   ◆
                              +-------------------+

•SingleOne ——▶ Basis (ירושה)

•MultiOne ——▶ Basis (ירושה)

•MultiOne ◆—— Basis (הכלה: MultiOne מכילה מערך של Basis)

זהו מבנה שבו "מיכל" (MultiOne) הוא בעצמו Basis ומכיל עצמי Basis – ולכן מיכל יכול להכיל גם מיכלים אחרים (כפי שקורה בסעיף ב').

תשובה: SingleOne ו-MultiOne יורשות מ-Basis (חצי ירושה אל Basis), ו-MultiOne מכילה Basis (קו הכלה עם המעוין בצד MultiOne).

סעיף ב

תשובה:

11, 35, 47, 22, 8, 17, 53, 40, 21, 13, 39, 62 (כל מספר בשורה נפרדת).

הערה על הקוד: בגרסת Java יש שגיאות הקלדה: `extended` במקום `extends`, `cout` במקום `count`, וחסר סוגר `}` בסוף הפעולה `add`. המעקב מתבצע לפי הכוונה הברורה (כמו בגרסת C#).

סימון העצמים: M1 – העצם שאליו מפנה `container`; M2 – העצם שאליו מפנה `subContainer`; O1...O6 – ששת עצמי SingleOne לפי סדר יצירתם. לכל MultiOne התכונה `num1` מקבלת 0 (בנאי `Basis()` ריק – ערך ברירת מחדל), ו-`arr` הוא מערך בגודל 5.

שלב הבנייה:

שורההוראהs1M1 (container): count, arrM2 (subContainer): count, arrעצם חדש (num1, num2)
1`container = new MultiOne()`–0, [ , , , , ]–M1: num1 = 0
2`s1 = new SingleOne(11, 35)`O10, [ , , , , ]–O1: 11, 35
3`container.add(s1)`O11, [O1, , , , ]–
4`s1 = new SingleOne(47, 22)`O21, [O1, , , , ]–O2: 47, 22
5`container.add(s1)`O22, [O1, O2, , , ]–
6`s1 = new SingleOne(8, 17)`O32, [O1, O2, , , ]–O3: 8, 17
7`container.add(s1)`O33, [O1, O2, O3, , ]–
8`subContainer = new MultiOne()`O33, [O1, O2, O3, , ]0, [ , , , , ]M2: num1 = 0
9`s1 = new SingleOne(53, 40)`O43, [O1, O2, O3, , ]0, [ , , , , ]O4: 53, 40
10`subContainer.add(s1)`O43, [O1, O2, O3, , ]1, [O4, , , , ]
11`s1 = new SingleOne(21, 13)`O53, [O1, O2, O3, , ]1, [O4, , , , ]O5: 21, 13
12`subContainer.add(s1)`O53, [O1, O2, O3, , ]2, [O4, O5, , , ]
13`s1 = new SingleOne(39, 62)`O63, [O1, O2, O3, , ]2, [O4, O5, , , ]O6: 39, 62
14`subContainer.add(s1)`O63, [O1, O2, O3, , ]3, [O4, O5, O6, , ]
15`container.add(subContainer)`O64, [O1, O2, O3, M2, ]3, [O4, O5, O6, , ]

בכל `add` התנאי `count < arr.length` מתקיים (count≤3<5count\le3<5), ולכן כל ההוספות מתבצעות. שימו לב: כל הצבה ל-`s1` יוצרת עצם חדש; העצמים הקודמים לא משתנים, כי המערך שומר הפניות אליהם.

שלב ההדפסה – `container.print()` (שילוב דינמי: לכל תא מתבצעת `print` של הטיפוס בפועל):

קריאהiarr[i]טיפוס בפועלמה מודפס
M1.print0O1SingleOne`super.print()` → 11, אחר כך 35
M1.print1O2SingleOne47, 22
M1.print2O3SingleOne8, 17
M1.print3M2MultiOneקריאה ל-M2.print
M2.print0O4SingleOne53, 40
M2.print1O5SingleOne21, 13
M2.print2O6SingleOne39, 62

הלולאה ב-M2 נעצרת ב-i=3=counti=3=count, וגם הלולאה ב-M1 נעצרת ב-i=4=counti=4=count.

הפלט (כל מספר בשורה נפרדת, כי משתמשים ב-println / WriteLine):

11
35
47
22
8
17
53
40
21
13
39
62

תשובה: הפלט הוא 11, 35, 47, 22, 8, 17, 53, 40, 21, 13, 39, 62 – כל מספר בשורה נפרדת.

כל האתר במבט אחד

קיצורי דרך לכל הכלים, הבגרויות והקורסים

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