מבחן מה"ט מבנה נתונים ותכנות מונחה עצמים 97105 - קיץ 2021 מועד ב'
הנדסת תוכנה · סמל 97105 · 11 שאלות · פתרון מלא לכל סעיף
מבחן הגמר הממלכתי של מה"ט במבנה נתונים ותכנות מונחה עצמים, קיץ 2021 מועד ב', כל 11 השאלות כמו בשאלון. לכל סעיף יש תשובה סופית ופתרון מלא ומוסבר, צעד אחרי צעד. נסו לפתור לבד, ואז פתחו את הפתרון.
הנחיות הבחינה
משך הבחינה: ארבע שעות וחצי.
מבחן ב- Java (עמוד 2)
מבחן ב- C# (עמוד 17)
בכל מבחן 11 שאלות.
שאלות 1-4: יש לענות על שלוש שאלות בלבד. ערך כל שאלה 15 נקודות.
שאלות 5-8: יש לענות על שתי שאלות בלבד. ערך כל שאלה 15 נקודות.
שאלות 9-11: יש לענות על שתי שאלות בלבד. ערך כל שאלה 12 נקודות.
נקודה אחת תינתן על הערכה.
חומר עזר: 1. מחשבון (אין להשתמש במחשב כף יד או במחשבון עם תקשורת חיצונית).
2. קלסר אחד בלבד עם חומר ההרצאות. אין להוציא דפים מהקלסר.
לשאלון מצורפים: נספח ממשקים לבחינה JAVA, נספח ממשקים לבחינה C# (ממשקי המחלקות Node, Stack, Queue).
שאלה 1 · תור מדרגה: בנייה ובדיקה
תור "מדרגה N" הוא תור של מספרים שלמים חיוביים שהמספר הראשון בו הוא 1 וכל מספר מופיע בו ברצף, מספר פעמים השווה לערכו, עד N. כלומר, 1 יופיע פעם אחת, לאחריו 2 יופיע 2 פעמים וכו'.
דוגמה לתור "מדרגה 4": 1,2,2,3,3,3,4,4,4,4.
כתבו פעולה שמקבלת מספר שלם חיובי N ומחזירה תור "מדרגה N".
כתבו פעולה המקבלת תור q של מספרים שלמים ומספר שלם חיובי N ומחזירה true אם התור הוא תור "מדרגה N", ואם לא, הפעולה מחזירה false.
◂ פתרון מלא לשאלה 1
סעיף א
לולאה חיצונית על i מ-1 עד N, ובתוכה לולאה שמכניסה את i לתור i פעמים; מחזירים את התור.
נתון: מספר שלם חיובי N.
מבוקש: תור חדש שבו 1 מופיע פעם אחת, 2 פעמיים, ..., N מופיע N פעמים, לפי הסדר.
הרעיון: התור נבנה מ-N "מדרגות". המדרגה ה-i היא i עותקים של המספר i. לכן:
1. יוצרים תור ריק.
2. לולאה חיצונית עוברת על הערכים - לפי הסדר, כי בתור מה שנכנס ראשון יוצא ראשון, וצריך ש-1 יהיה בראש התור.
3. לולאה פנימית מכניסה את i לסוף התור בדיוק i פעמים.
4. מחזירים את התור.
מספר האיברים בתור הוא , ולכן הסיבוכיות - וזה הכרחי, כי זה גודל הפלט.
public static Queue<Integer> stepQueue(int n)
{
Queue<Integer> q = new Queue<Integer>();
for (int i = 1; i <= n; i++) // הערך i
for (int k = 1; k <= i; k++) // מופיע i פעמים
q.insert(i);
return q;
}public static Queue<int> StepQueue(int n)
{
Queue<int> q = new Queue<int>();
for (int i = 1; i <= n; i++) // הערך i
for (int k = 1; k <= i; k++) // מופיע i פעמים
q.Insert(i);
return q;
}דוגמה: עבור מתקבל התור (ראש התור משמאל) 1, 2, 2, 3, 3, 3, 4, 4, 4, 4.
תשובה: הפעולה `stepQueue` / `StepQueue` שלמעלה.
סעיף ב
מעבר אחד על התור עם הערך הצפוי expected (מתחיל ב-1) ומונה count; כל איבר חייב להיות שווה ל-expected, וכש-count מגיע ל-expected עוברים לערך הבא. בסוף צריך expected = N+1 ו-count = 0. התור מוחזר למצבו המקורי בעזרת תור עזר.
נתון: תור q של מספרים שלמים ומספר שלם חיובי N.
מבוקש: true אם q הוא בדיוק 1, 2, 2, 3, 3, 3, ..., N (N פעמים), אחרת false.
הרעיון: עוברים על איברי התור לפי הסדר ויודעים בכל רגע איזה ערך אמור להופיע:
1. משתנה `expected` - הערך שאמור להופיע עכשיו (מתחיל ב-1), ומשתנה `count` - כמה פעמים הוא כבר הופיע ברצף (מתחיל ב-0).
2. מוציאים איבר x מהתור ומעבירים אותו לתור עזר `temp`, כדי שבסוף נוכל להחזיר את q למצבו המקורי (פעולה שבודקת לא אמורה להרוס את הקלט).
3. אם - התור אינו "מדרגה N", ומסמנים `ok = false`. לא עוצרים את הלולאה, כי צריך להמשיך ולהעביר את כל האיברים לתור העזר.
4. אחרת מגדילים את `count`. כאשר , הערך הופיע מספר פעמים השווה לערכו, ולכן עוברים לערך הבא: `expected++` ו-`count = 0`.
5. בסוף הלולאה מחזירים את האיברים מ-`temp` ל-q (הסדר נשמר, כי שני התורים הם FIFO).
6. התור תקין אם לא נמצאה שגיאה, וגם הושלמו בדיוק N מדרגות: (המדרגה האחרונה שהושלמה היא N) ו- (אין מדרגה חלקית בסוף).
הבדיקה בשלב 6 תופסת גם תור קצר מדי (למשל 1, 2, 2, 3, 3 עבור : בסוף , ) וגם תור ארוך מדי (למשל תור "מדרגה 4" עם : בסוף ).
הסיבוכיות: כל איבר מוצא ומוכנס פעמיים, כלומר כאשר n מספר האיברים בתור.
public static boolean isStepQueue(Queue<Integer> q, int n)
{
Queue<Integer> temp = new Queue<Integer>();
boolean ok = true;
int expected = 1; // הערך שאמור להופיע עכשיו
int count = 0; // כמה פעמים הוא כבר הופיע
while (!q.isEmpty())
{
int x = q.remove();
temp.insert(x);
if (x != expected)
ok = false;
else
{
count++;
if (count == expected) // הערך הופיע מספר פעמים השווה לערכו
{
expected++;
count = 0;
}
}
}
while (!temp.isEmpty()) // החזרת התור למצבו המקורי
q.insert(temp.remove());
return ok && expected == n + 1 && count == 0;
}public static bool IsStepQueue(Queue<int> q, int n)
{
Queue<int> temp = new Queue<int>();
bool ok = true;
int expected = 1; // הערך שאמור להופיע עכשיו
int count = 0; // כמה פעמים הוא כבר הופיע
while (!q.IsEmpty())
{
int x = q.Remove();
temp.Insert(x);
if (x != expected)
ok = false;
else
{
count++;
if (count == expected) // הערך הופיע מספר פעמים השווה לערכו
{
expected++;
count = 0;
}
}
}
while (!temp.IsEmpty()) // החזרת התור למצבו המקורי
q.Insert(temp.Remove());
return ok && expected == n + 1 && count == 0;
}•התור 1, 2, 2, 3, 3, 3, 4, 4, 4, 4 עם : כל איבר שווה לערך הצפוי, ובסוף , - יוחזר true.
•התור 1, 2, 3, 2, 3, 3 עם : האיבר השלישי הוא 3 אבל הצפוי הוא 2 - יוחזר false.
תשובה: הפעולה `isStepQueue` / `IsStepQueue` שלמעלה.
שאלה 2 · שרשרת סכומים ושרשרת סכומים הפוכה
"שרשרת סכומים" היא שרשרת של מספרים שלמים שכל מספר בה (פרט לראשון) הוא סכום של המספרים אשר מופיעים לפניו.
דוגמה ל"שרשרת סכומים":

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

כתבו פעולה אשר מקבלת הפניה לחוליה ראשונה של שרשרת חוליות ומחזירה true אם השרשרת היא "שרשרת סכומים הפוכה", ואם לא, הפעולה מחזירה false.
◂ פתרון מלא לשאלה 2
סעיף א
שומרים את סכום המספרים שלפני החוליה הנוכחית (מתחיל בערך הראשון); כל חוליה מהשנייה ואילך חייבת להיות שווה לסכום הזה, ואז מוסיפים אותה לסכום. אם יש אי-שוויון מחזירים false, אחרת true.
נתון: הפניה לחוליה הראשונה של שרשרת מספרים שלמים.
מבוקש: לבדוק שכל מספר, פרט לראשון, שווה לסכום כל המספרים שלפניו.
הרעיון: אין צורך לחשב מחדש את הסכום עבור כל חוליה. מחזיקים משתנה `sum` - סכום כל המספרים שכבר עברנו (סכום מצטבר):
1. אם השרשרת ריקה - אין מספר שמפר את התנאי, ומחזירים true.
2. מתחילים עם `sum` = ערך החוליה הראשונה (לראשון אין תנאי).
3. עוברים על החוליות מהשנייה ואילך. לכל חוליה בודקים שהערך שלה שווה ל-`sum`. אם לא - מחזירים false מיד.
4. אחרי הבדיקה מוסיפים את הערך ל-`sum`, כי עכשיו הוא חלק מ"המספרים שלפני" החוליה הבאה.
5. אם עברנו את כל השרשרת בלי סתירה - מחזירים true.
מעבר אחד על השרשרת: סיבוכיות .
public static boolean isSumChain(Node<Integer> lst)
{
if (lst == null)
return true;
int sum = lst.getValue(); // סכום כל המספרים שלפני החוליה הנוכחית
Node<Integer> p = lst.getNext();
while (p != null)
{
if (p.getValue() != sum)
return false;
sum += p.getValue();
p = p.getNext();
}
return true;
}public static bool IsSumChain(Node<int> lst)
{
if (lst == null)
return true;
int sum = lst.GetValue(); // סכום כל המספרים שלפני החוליה הנוכחית
Node<int> p = lst.GetNext();
while (p != null)
{
if (p.GetValue() != sum)
return false;
sum += p.GetValue();
p = p.GetNext();
}
return true;
}מעקב על הדוגמה 1, 1, 2, 4, 8, 16, 32:
כל הבדיקות עברו, ולכן יוחזר true.
תשובה: הפעולה `isSumChain` / `IsSumChain` שלמעלה.
סעיף ב
מעבר ראשון: total = סכום כל השרשרת. מעבר שני עם before = סכום המספרים שלפני החוליה: לכל חוליה פרט לאחרונה, סכום המספרים שאחריה הוא total - before - value, והערך חייב להיות שווה לו; אחרת false.
נתון: הפניה לחוליה הראשונה של שרשרת מספרים שלמים.
מבוקש: לבדוק שכל מספר, פרט לאחרון, שווה לסכום כל המספרים שאחריו.
הקושי: בשרשרת חד-כיוונית אפשר להתקדם רק קדימה, ולכן "סכום המספרים שאחרי" לא ידוע כשמגיעים לחוליה. חישוב שלו מחדש לכל חוליה ייתן .
הרעיון: אם יודעים את סכום כל השרשרת (total) ואת סכום המספרים שלפני החוליה (before), אז
ולכן מספיקים שני מעברים:
1. מעבר ראשון: מחשבים את `total` - סכום כל הערכים.
2. מעבר שני: מתחילים עם `before = 0`. לכל חוליה שיש אחריה חוליה (פרט לאחרונה) מחשבים את `after` לפי הנוסחה, ובודקים ש-`value == after`. אם לא - מחזירים false.
3. אחרי הבדיקה מוסיפים את הערך ל-`before` ומתקדמים.
4. אם כל הבדיקות עברו - מחזירים true. שרשרת ריקה או בת חוליה אחת מקיימת את התנאי באופן ריק.
שני מעברים: סיבוכיות .
public static boolean isReverseSumChain(Node<Integer> lst)
{
int total = 0; // מעבר ראשון: סכום כל השרשרת
for (Node<Integer> p = lst; p != null; p = p.getNext())
total += p.getValue();
int before = 0; // סכום המספרים שלפני החוליה הנוכחית
Node<Integer> p = lst;
while (p != null && p.getNext() != null) // כל החוליות פרט לאחרונה
{
int after = total - before - p.getValue(); // סכום המספרים שאחריה
if (p.getValue() != after)
return false;
before += p.getValue();
p = p.getNext();
}
return true;
}public static bool IsReverseSumChain(Node<int> lst)
{
int total = 0; // מעבר ראשון: סכום כל השרשרת
for (Node<int> q = lst; q != null; q = q.GetNext())
total += q.GetValue();
int before = 0; // סכום המספרים שלפני החוליה הנוכחית
Node<int> p = lst;
while (p != null && p.GetNext() != null) // כל החוליות פרט לאחרונה
{
int after = total - before - p.GetValue(); // סכום המספרים שאחריה
if (p.GetValue() != after)
return false;
before += p.GetValue();
p = p.GetNext();
}
return true;
}מעקב על הדוגמה 64, 32, 16, 8, 4, 2, 2: .
החוליה האחרונה (2) לא נבדקת, ויוחזר true.
תשובה: הפעולה `isReverseSumChain` / `IsReverseSumChain` שלמעלה.
שאלה 3 · שחזור היררכיית ירושה מהשמות והמרות
נתונה התוכנית הראשית הבאה (הניחו כי כל השורות בקוד הן תקינות):
public static void main(String[] args)
{
B b1 = new A();
B b2 = new C();
A a1 = (C) b2;
D d1 = new C();
B b3 = new B();
D d2 = new A();
}public static void Main(string[] args)
{
B b1 = new A();
B b2 = new C();
A a1 = (C) b2;
D d1 = new C();
B b3 = new B();
D d2 = new A();
}שרטטו תרשים UML המתאר קשר אפשרי ונכון בין כל המחלקות המוזכרות בקוד.
הניחו כי השורה האחרונה בקוד מבצעת המרה לא תקינה (המחשב מודיע על טעות). שרטטו תרשים UML חדש המתאר את הקשרים הנכונים במקרה זה, בין כל המחלקות המוזכרות בקוד.
◂ פתרון מלא לשאלה 3
סעיף א
C יורשת מ-A, A יורשת מ-B, B יורשת מ-D (שרשרת D ← B ← A ← C). B אינה מופשטת; D יכולה להיות מופשטת.
הכלל: השמה `X x = new Y();` (או השמה של ביטוי מטיפוס Y למשתנה מטיפוס X) תקינה רק אם Y הוא X, כלומר Y זהה ל-X או יורשת ממנה (ישירות או בעקיפין). המרה מפורשת `(Y) x` מתקבלת בהידור כאשר Y יורשת מהטיפוס של x.
נעבור על השורות ונרשום מה כל אחת מחייבת:
1. C יורשת מ-A, ו-A יורשת מ-B - לכן C ← A ← B (וגם "C יורשת מ-B" מתקיים בעקיפין).
2. גם A וגם C צריכות לרשת מ-D. בירושה יחידה, D חייבת להיות "מעל" A. הבחירה הפשוטה: B יורשת מ-D.
התרשים (החץ מצביע מהמחלקה היורשת אל מחלקת העל):
D
^
|
B
^
|
A
^
|
Cמכיוון שלא יוצרים עצם מסוג D, היא יכולה להיות גם מחלקה מופשטת. (אפשרויות נכונות נוספות: D בין B ל-A, כלומר B ← D ← A (A יורשת מ-D ו-D יורשת מ-B); או D ממשק ש-B מממשת.)
תשובה: C יורשת מ-A, A יורשת מ-B ו-B יורשת מ-D.
סעיף ב
D ממוקמת בין A ל-C: C יורשת מ-D, D יורשת מ-A, A יורשת מ-B (שרשרת B ← A ← D ← C).
מה השתנה: השורה `D d2 = new A();` אינה תקינה, כלומר A אינה יורשת מ-D. כל שאר השורות עדיין תקינות, ולכן עדיין:
•A יורשת מ-B, ו-C יורשת מ-A (שורות 1-3);
•C יורשת מ-D (שורה 4);
•B מחלקה רגילה (שורה 5).
1. C צריכה לרשת גם מ-A וגם מ-D, אבל A לא יורשת מ-D. לכן D לא יכולה להיות "מעל" A.
2. בירושה יחידה, המקום היחיד ל-D הוא בין A ל-C: C יורשת מ-D, ו-D יורשת מ-A.
3. בדיקה: C עדיין יורשת מ-A (דרך D) ומ-B, ולכן שורות 1-4 תקינות. A היא מחלקת על של D, ולכן אי אפשר להציב עצם מסוג A במשתנה מסוג D - שגיאת הידור בשורה האחרונה, כנדרש.
B
^
|
A
^
|
D
^
|
C(אפשרות נכונה נוספת: D ממשק ש-C בלבד מממשת, ו-C יורשת מ-A ו-A מ-B.)
תשובה: B ← A ← D ← C: מחלקה D יורשת מ-A, ו-C יורשת מ-D.
שאלה 4 · העמסה, דריסה ושגיאות הידור
נתונה המחלקה A הבאה:
public class A
{
public int foo (int i)
{
return i;
}
}public class A
{
public int Foo (int i)
{
return i;
}
}עבור אחת מהפעולות 5-1 הבאות קבעו מה יתרחש אם מוסיפים את הפעולה למחלקה A.
בררו את האפשרות המתאימה מאפשרויות הבאות:
•שגיאת קומפילציה.
•שגיאת זמן ריצה.
•קוד תקין, דריסה (overriding).
•קוד תקין, העמסה (overloading).
1. public int foo () { return 1; }
2. public int foo(double i){ return (int)i; }
3. public double foo(int i){ return i; }
4. public double foo(double i){ return i; }
5. public void foo(double i){ System.out.print(i); }1. public int Foo () { return 1; }
2. public int Foo(double i){ return (int)i; }
3. public double Foo(int i){ return i; }
4. public double Foo(double i){ return i; }
5. public void Foo(double i){ Console.Write (i); }ב-C# בלבד: חתימה של הפעולה Foo השתנתה:
public virtual int Foo (int i)עבור אחת מהפעולות 5-1 הבאות קבעו מה יתרחש אם מוסיפים את הפעולה למחלקה B שיורשת מ- A.
בררו את האפשרות המתאימה מאפשרויות הבאות:
•שגיאת קומפילציה.
•שגיאת זמן ריצה.
•קוד תקין, דריסה (overriding).
•קוד תקין, העמסה (overloading).
1. public int foo () { return 10; }
2. public int foo(int i){ return i*10; }
3. public double foo(int i){ return i*10; }
4. public double foo(double i){ return i*10; }
5. public void foo(double i){ System.out.print(i); }1. public int Foo () { return 10; }
2. public override int Foo(int i){ return i*10; }
3. public override double Foo(int i){ return i*10; }
4. public double Foo(double i){ return i*10; }
5. public override void Foo(double i){ Console.Write(i); }◂ פתרון מלא לשאלה 4
סעיף א
1 - העמסה; 2 - העמסה; 3 - שגיאת קומפילציה; 4 - העמסה; 5 - העמסה (זהה ב-Java וב-C#).
•העמסה (overloading): באותה מחלקה (או במחלקה יורשת) כמה פעולות באותו שם עם רשימת פרמטרים שונה (מספר או טיפוסים). טיפוס הערך המוחזר אינו חלק מהחתימה, ולכן הוא יכול להיות שונה.
•דריסה (overriding): פעולה במחלקה יורשת עם אותה חתימה בדיוק כמו במחלקת העל. בתוך אותה מחלקה אין דריסה.
•שתי פעולות באותה מחלקה עם אותו שם ואותה רשימת פרמטרים - שגיאת קומפילציה, גם אם טיפוס ההחזרה שונה, כי המהדר לא יוכל להבחין ביניהן בזימון `foo(5)`.
•כל ההוספות כאן נבדקות בזמן ההידור, ולכן אף אחת מהן לא גורמת לשגיאת זמן ריצה.
הפעולה הקיימת: `int foo(int i)`. כל פעולה נבדקת בנפרד (מוסיפים אותה לבדה):
בפעולה 3 החתימה `foo(int)` כבר קיימת במחלקה A, וטיפוס החזרה שונה (double) לא מספיק כדי להבדיל. בפעולות 2, 4, 5 רשימת הפרמטרים היא (double), שונה מ-(int), ולכן כל אחת מהן לבדה היא העמסה חוקית. התשובה זהה ב-C# (שם השגיאה בפעולה 3: המחלקה כבר מגדירה פעולה בשם Foo עם אותם טיפוסי פרמטרים).
תשובה: 1 - העמסה, 2 - העמסה, 3 - שגיאת קומפילציה, 4 - העמסה, 5 - העמסה.
סעיף ב
Java: 1 - העמסה; 2 - דריסה; 3 - שגיאת קומפילציה; 4 - העמסה; 5 - העמסה. C#: 1 - העמסה; 2 - דריסה; 3 - שגיאת קומפילציה; 4 - העמסה; 5 - שגיאת קומפילציה.
עכשיו הפעולה נוספת למחלקה B שיורשת מ-A, ולכן B מכילה גם את `foo(int)` שירשה. כל פעולה נבדקת בנפרד:
•חתימה שונה מ-`foo(int)` - העמסה (ב-B יש עכשיו שתי פעולות foo: הירושה והחדשה).
•חתימה זהה וטיפוס החזרה זהה - דריסה.
•חתימה זהה וטיפוס החזרה שונה - שגיאת קומפילציה: זו לא העמסה (הפרמטרים זהים) וגם לא דריסה חוקית (בדריסה טיפוס ההחזרה חייב להתאים).
C#: ב-C# הפעולה ב-A הוגדרה `virtual`, ודריסה נכתבת במפורש עם `override`. המילה `override` מחייבת שבמחלקת העל תהיה פעולה וירטואלית עם אותה חתימה ואותו טיפוס החזרה:
ההבדל היחיד בין השפות הוא בפעולה 5: ב-Java זו פעולה חדשה עם פרמטר double, כלומר העמסה. ב-C# היא מסומנת `override` בלי שיש מה לדרוס, ולכן היא שגיאה.
תשובה: Java: 1 - העמסה, 2 - דריסה, 3 - שגיאת קומפילציה, 4 - העמסה, 5 - העמסה. C#: 1 - העמסה, 2 - דריסה, 3 - שגיאת קומפילציה, 4 - העמסה, 5 - שגיאת קומפילציה.
שאלה 5 · בניית מחלקת על מתוך מחלקה יורשת
נתונה מחלקת Child
public class Child extends Parent
{
private int y;
public Child( String name, double x)
{
super(x, name);
this.y = 10;
System.out.println( this.x );
}
public Child(int y)
{
super(6.5,"David","Cohen");
this.y = y;
}
public int sum()
{
System.out.println(this.name+" "+this.getLastName());
return this.y + this.method();
}
public double calculate(double d)
{
return d * super.calculate(5.2);
}
public void print()
{
super.print();
System.out.println("Child");
}
public int getYear()
{
return Parent.year;
}
}class Child: Parent
{
private int y;
public Child(string name, double x) : base(x, name)
{
this.y = 10;
Console.WriteLine(this.x);
}
public Child(int y) : base(6.5, "David", "Cohen")
{
this.y = y;
}
public int Sum()
{
Console.WriteLine(this.name+" " + this.GetLastName());
return this.y + this.Method();
}
public override double Calculate(double d)
{
return d * base.Calculate(5.2);
}
public override void Print()
{
base.Print();
Console.WriteLine("Child");
}
public int GetYear()
{
return Parent.year;
}
}כתבו את מחלקת העל - Parent (את המחלקה המורישה) של המחלקת Child.
מחלקת העל צריכה להכיל את כל התכונות והפעולות המתחייבות ממחלקת Child.
היכן בשתי המחלקות ישנה העמסה? הסבירו את תשובתכם.
היכן בשתי המחלקות ישנה דריסה? הסבירו את תשובתכם.
ממשו במחלקה חיצונית את הפעולה:
public static void output(Object[] arr)public static void Output(Object[] arr)הפעולה מקבלת מערך של עצמים. עבור כל עצם מסוג Parent או Child במערך, הפעולה תזמן את פעולת print() המתאימה לסוג העצם.
◂ פתרון מלא לשאלה 5
סעיף א
Parent: תכונות protected double x, protected String name, private String lastName, protected static int year; בנאים Parent(double x, String name) ו-Parent(double x, String name, String lastName); פעולות String getLastName(), int method(), double calculate(double), void print() (ב-C#: Calculate ו-Print וירטואליות).
הרעיון: עוברים על Child שורה אחר שורה, ולכל שימוש במשהו שאינו מוגדר ב-Child מסיקים מה חייב להיות ב-Parent - כולל הטיפוס וההרשאה:
ב-C# פעולה שנדרסת עם `override` חייבת להיות מוגדרת `virtual` במחלקת העל, ולכן `Calculate` ו-`Print` מוגדרות ב-Parent כ-`virtual`.
מכיוון שאין צורך לממש, גופי הפעולות כאן מינימליים:
public class Parent
{
protected static int year; // Parent.year
protected String name; // this.name
protected double x; // this.x
private String lastName; // getLastName()
public Parent(double x, String name) // super(x, name)
{
this.x = x;
this.name = name;
}
public Parent(double x, String name, String lastName) // super(6.5,"David","Cohen")
{
this.x = x;
this.name = name;
this.lastName = lastName;
}
public String getLastName() { return this.lastName; }
public int method() { return 0; }
public double calculate(double d) { return d; }
public void print() { System.out.println(this.name); }
}public class Parent
{
protected static int year; // Parent.year
protected string name; // this.name
protected double x; // this.x
private string lastName; // GetLastName()
public Parent(double x, string name) // base(x, name)
{
this.x = x;
this.name = name;
}
public Parent(double x, string name, string lastName) // base(6.5, "David", "Cohen")
{
this.x = x;
this.name = name;
this.lastName = lastName;
}
public string GetLastName() { return this.lastName; }
public int Method() { return 0; }
public virtual double Calculate(double d) { return d; }
public virtual void Print() { Console.WriteLine(this.name); }
}תשובה: מחלקת Parent שלמעלה.
סעיף ב
העמסת בנאים: ב-Child שני בנאים - Child(String, double) ו-Child(int); ב-Parent שני בנאים - Parent(double, String) ו-Parent(double, String, String).
העמסה היא כמה פעולות (או בנאים) באותו שם עם רשימות פרמטרים שונות; המהדר בוחר ביניהן לפי הארגומנטים בזימון.
1. במחלקה Child: שני בנאים -
•`Child(String name, double x)` - שני פרמטרים;
•`Child(int y)` - פרמטר אחד.
אותו שם, רשימות פרמטרים שונות - העמסת בנאים.
2. במחלקה Parent: שני בנאים (שנובעים משתי הקריאות ל-super) -
•`Parent(double x, String name)`;
•`Parent(double x, String name, String lastName)`.
גם כאן אותו שם ומספר פרמטרים שונה - העמסת בנאים.
אין העמסה של פעולות רגילות: כל פעולה רגילה מופיעה עם רשימת פרמטרים אחת בלבד.
תשובה: ההעמסה היא של הבנאים: שני בנאים ב-Child ושני בנאים ב-Parent, עם רשימות פרמטרים שונות.
סעיף ג
הפעולות calculate(double) ו-print() של Child דורסות את הפעולות בעלות אותה חתימה ב-Parent (ב-C# מסומנות override).
דריסה היא הגדרה מחדש במחלקה היורשת של פעולה שקיימת במחלקת העל, עם אותה חתימה ואותו טיפוס החזרה. בזמן ריצה מופעלת הגרסה של הטיפוס האמיתי של העצם.
1. `double calculate(double d)` - קיימת ב-Parent (Child קוראת ל-`super.calculate(5.2)`) ומוגדרת מחדש ב-Child: מחזירה d כפול תוצאת הגרסה של מחלקת העל.
2. `void print()` - קיימת ב-Parent (Child קוראת ל-`super.print()`) ומוגדרת מחדש ב-Child: מדפיסה את מה ש-Parent מדפיסה ואחר כך "Child".
ב-C# הדריסה מפורשת: הפעולות מסומנות `override` ב-Child ו-`virtual` ב-Parent. הפעולות `sum`, `getYear` חדשות ב-Child (לא קיימות ב-Parent), ולכן אינן דריסה.
תשובה: הדריסה היא בפעולות calculate(double) ו-print() של Child, שדורסות את הפעולות התואמות ב-Parent.
סעיף ד
לולאה על המערך; אם arr[i] instanceof Parent (ב-C#: is Parent) - ממירים ל-Parent ומזמנים print(); הקישור הדינמי מפעיל את print של Child עבור עצם מסוג Child.
1. המערך הוא מטיפוס Object, ולכן אי אפשר לזמן עליו ישירות `print()` - צריך לבדוק את סוג העצם ולהמיר.
2. עצם מסוג Child הוא גם Parent (ירושה), ולכן בדיקה אחת `instanceof Parent` (ב-C#: `is Parent`) תופסת את שני הסוגים. עבור null ועבור עצמים מסוגים אחרים הבדיקה מחזירה false, והם מדולגים.
3. אחרי ההמרה ל-Parent מזמנים `print()`. מכיוון ש-print נדרסת ב-Child, הקישור הדינמי מפעיל בזמן ריצה את הגרסה של הטיפוס האמיתי: עבור Parent - הגרסה של Parent, ועבור Child - הגרסה של Child. כך מתקבלת בדיוק "פעולת print() המתאימה לסוג העצם" בלי לבדוק את Child בנפרד.
public static void output(Object[] arr)
{
for (int i = 0; i < arr.length; i++)
if (arr[i] instanceof Parent) // נכון גם לעצם מסוג Child
((Parent) arr[i]).print(); // קישור דינמי: print של הסוג האמיתי
}public static void Output(Object[] arr)
{
for (int i = 0; i < arr.Length; i++)
if (arr[i] is Parent) // נכון גם לעצם מסוג Child
((Parent)arr[i]).Print(); // קישור דינמי: Print של הסוג האמיתי
}דוגמה: עבור המערך { עצם Child, מחרוזת, עצם Parent } יופעלו print של Child על העצם הראשון ו-print של Parent על השלישי, והמחרוזת תדולג.
תשובה: הפעולה `output` / `Output` שלמעלה.
שאלה 6 · שערי מטבע חוץ ברשימה מקושרת
מטבע חוץ ForeignCurrency מאופיין באמצעות שם המטבע (למשל דולר, יורו, פאונד וכו') ורשימה של שווי המטבע בשקלים (זהו שער המטבע) במשך תקופה מסוימת. לכל יום בתקופה יש שער משלו. האיבר בראש הרשימה מציין את שער היום הנוכחי.
להלן ייצוג המחלקה:
class ForeignCurrency
{
private String name;
private Node<Double> rates;class ForeignCurrency
{
private string name;
private Node<double> rates;במחלקה הוגדרו פעולה בונה ופעולות set/get.
כתבו פעולה פנימית addRate(double rate) המוסיפה שער מטבע ביום הנוכחי.
מטבע נחשב בשיא שלו אם השער הנוכחי שלו גבוה מכל השערים הקודמים שלו.
כתבו פעולה פנימית המחזירה true אם המטבע נמצא בשיא שלו.
מטבע נחשב "כדאי להשקעה" אם השער שלו עלה לפחות בחמישה הימים האחרונים אבל לא נמצא בשיא.
כתבו פעולה פנימית המחזירה true אם מטבע הוא "כדאי להשקעה", ואם לא, הפעולה תחזיר false.
אפשר להניח שברשימת השערים יש מידע על לפחות חמשת הימים האחרונים.
◂ פתרון מלא לשאלה 6
סעיף א
יוצרים חוליה חדשה עם rate שהעוקבת שלה היא rates הנוכחית, ומציבים אותה בראש: rates = new Node<Double>(rate, rates).
הרעיון: ראש הרשימה מייצג את היום הנוכחי. שער של יום חדש הופך להיות "היום הנוכחי", ולכן מוסיפים אותו בראש הרשימה, והשער שהיה עד עכשיו בראש הופך לשער של היום הקודם:
1. יוצרים חוליה חדשה שהערך שלה rate, והחוליה העוקבת לה היא הראש הנוכחי `rates` (גם אם הרשימה ריקה, ואז העוקבת היא null).
2. מציבים את החוליה החדשה ב-`rates`.
הוספה בראש היא .
public void addRate(double rate)
{
this.rates = new Node<Double>(rate, this.rates);
}public void AddRate(double rate)
{
this.rates = new Node<double>(rate, this.rates);
}תשובה: הפעולה `addRate` / `AddRate` שלמעלה.
סעיף ב
today = הערך בראש הרשימה; עוברים על שאר החוליות, ואם אחת מהן גדולה או שווה ל-today מחזירים false; אחרת true (רשימה ריקה - false).
נתון: הרשימה `rates`, שבראשה השער הנוכחי ואחריו השערים הקודמים.
מבוקש: true אם השער הנוכחי גבוה ממש מכל שער קודם.
1. אם הרשימה ריקה - אין שער נוכחי, ומחזירים false.
2. שומרים את השער הנוכחי `today` (הערך בראש הרשימה).
3. עוברים על כל החוליות שאחרי הראש. אם נמצא שער קודם גדול או שווה ל-today - השער הנוכחי אינו גבוה מכולם, ומחזירים false מיד.
4. אם לא נמצא שער כזה - מחזירים true. (כשיש שער אחד בלבד אין שערים קודמים, והתנאי מתקיים.)
מעבר אחד על הרשימה: .
public boolean isPeak()
{
if (this.rates == null)
return false;
double today = this.rates.getValue();
Node<Double> p = this.rates.getNext();
while (p != null)
{
if (p.getValue() >= today)
return false;
p = p.getNext();
}
return true;
}public bool IsPeak()
{
if (this.rates == null)
return false;
double today = this.rates.GetValue();
Node<double> p = this.rates.GetNext();
while (p != null)
{
if (p.GetValue() >= today)
return false;
p = p.GetNext();
}
return true;
}דוגמה: עבור הרשימה (מהיום אחורה) 3.7, 3.5, 3.6, 3.2 - כל השערים הקודמים קטנים מ-3.7, ויוחזר true. עבור 3.5, 3.45, 3.6 - השער 3.6 גבוה מ-3.5, ויוחזר false.
תשובה: הפעולה `isPeak` / `IsPeak` שלמעלה.
סעיף ג
בודקים שחמשת השערים הראשונים ברשימה יורדים ממש מהראש והלאה (כלומר השער עלה מיום ליום בחמשת הימים האחרונים) - 4 השוואות; אם כן, מחזירים !isPeak(), אחרת false.
נתון: ברשימה יש לפחות 5 שערים. הראש הוא היום, החוליה השנייה אתמול, וכן הלאה.
מבוקש: true אם השער עלה ברציפות בחמשת הימים האחרונים, ובכל זאת המטבע אינו בשיא.
פירוש התנאי: "השער עלה בחמשת הימים האחרונים" - בכל אחד מחמשת הימים האחרונים השער גבוה מהשער של היום שלפניו, בתוך חמשת הימים. ברשימה (שבה היום בראש) המשמעות היא שחמש החוליות הראשונות יורדות ממש:
כאשר השער של היום. לכך מספיק המידע על חמשת הימים, כפי שמובטח בשאלה.
1. עוברים על ארבעת הזוגות הסמוכים מבין חמשת השערים הראשונים: .
2. אם באחד הזוגות השער החדש לא גבוה מהשער הקודם לו () - השער לא עלה ברציפות, ומחזירים false.
3. אם כל ארבע ההשוואות עברו - השער עלה בכל הימים. נשאר לבדוק שהמטבע לא בשיא: מחזירים את השלילה של הפעולה מסעיף ב.
ההשוואות , ובדיקת השיא .
public boolean isWorthInvesting()
{
Node<Double> p = this.rates;
for (int i = 0; i < 4; i++) // 4 השוואות בין 5 הימים האחרונים
{
if (p.getValue() <= p.getNext().getValue()) // היום לא גבוה מאתמול
return false;
p = p.getNext();
}
return !isPeak();
}public bool IsWorthInvesting()
{
Node<double> p = this.rates;
for (int i = 0; i < 4; i++) // 4 השוואות בין 5 הימים האחרונים
{
if (p.GetValue() <= p.GetNext().GetValue()) // היום לא גבוה מאתמול
return false;
p = p.GetNext();
}
return !IsPeak();
}דוגמה: הרשימה (מהיום אחורה) 3.5, 3.45, 3.4, 3.3, 3.2, 3.6: חמשת השערים הראשונים יורדים ממש (השער עלה בכל יום), אבל ב-3.6 יש שער קודם גבוה מ-3.5, כלומר המטבע לא בשיא - יוחזר true. אם יתווסף שער של 3.7, המטבע יהיה בשיא, ויוחזר false.
תשובה: הפעולה `isWorthInvesting` / `IsWorthInvesting` שלמעלה.
שאלה 7 · המרות טיפוסים בהיררכיית מחלקות
לפניכם היררכיית מחלקות והפעולה method() הנמצאת במחלקה Dog.

נתון קטע בפעולה הראשית (main)
Mammal mam = new Bulldog();
Dog dog = new Beagle();
Bulldog bul = new Bulldog();
******בהתייחס לכל אחת מהשורות הבאות, כתבו מה יקרה בעקבות הוספת לקטע קוד שלעיל, לאחר ההצהרות על האובייקטים (במקום שמסומן בכוכביות*).
אם ההוראה אינה תקינה, ציינו נוסף להסבר, האם הוראה תגרום לשגיאת הידור (קומפילציה) או לשגיאת זמן ריצה.
1. Cat d1 = (Cat)mam;
2. Cat d2 = (Cat)((Mammal)mam);
3. Mammal d3 = (Cat)new Bengal();
4. Dog d4 = (Mammal)dog;
5. Beagle d5 = (Mammal)new Dog();
6. Object d6 = (Bengal)new Cat();
7. ((Bulldog)((Mammal)bul)).method();1. Cat d1 = (Cat)mam;
2. Cat d2 = (Cat)((Mammal)mam);
3. Mammal d3 = (Cat)new Bengal();
4. Dog d4 = (Mammal)dog;
5. Beagle d5 = (Mammal)new Dog();
6. Object d6 = (Bengal)new Cat();
7. ((Bulldog)((Mammal)bul)).Method();◂ פתרון מלא לשאלה 7
פתרון
1 - שגיאת זמן ריצה; 2 - שגיאת זמן ריצה; 3 - תקינה; 4 - שגיאת הידור; 5 - שגיאת הידור; 6 - שגיאת זמן ריצה; 7 - תקינה (מופעלת method של Dog).
•בזמן הידור המהדר מכיר רק את הטיפוס המוצהר של כל ביטוי.
•השמה מטיפוס "צר" לטיפוס "רחב" (ממחלקה יורשת למחלקת על) תקינה תמיד.
•השמה מטיפוס רחב למשתנה מטיפוס צר בלי המרה מפורשת - שגיאת הידור.
•המרה מפורשת `(X)e` מתקבלת בהידור רק אם X והטיפוס של e באותו קו ירושה (אחד יורש מהשני).
•בזמן ריצה המרה כלפי מטה `(X)e` נבדקת מול הטיפוס האמיתי של העצם. אם העצם אינו X (או יורש ממנו) - שגיאת זמן ריצה (ב-Java: ClassCastException, ב-C#: InvalidCastException).
מצב המשתנים: `mam` מוצהר Mammal ומצביע על עצם Bulldog; `dog` מוצהר Dog ומצביע על Beagle; `bul` מוצהר Bulldog ומצביע על Bulldog.
•שורות 1, 2, 6: המהדר "סומך" על המתכנת בהמרה כלפי מטה, כי בהחלט ייתכן שמשתנה מטיפוס Mammal מצביע על Cat. רק בזמן ריצה מתגלה שהעצם האמיתי (Bulldog בשורות 1-2, Cat "סתם" בשורה 6) אינו מהטיפוס המבוקש.
•שורות 4, 5: ההמרה `(Mammal)` מחזירה ביטוי מטיפוס Mammal, ולא כל Mammal הוא Dog או Beagle. המהדר לא מרשה השמה כזו בלי המרה מפורשת לטיפוס היעד.
•שורה 7: ההמרה ל-Mammal ובחזרה ל-Bulldog תקינה, כי העצם הוא אכן Bulldog. Bulldog יורשת מ-Dog, ולכן מופעלת הפעולה method() שהוגדרה ב-Dog.
תשובה: 1 - שגיאת זמן ריצה; 2 - שגיאת זמן ריצה; 3 - תקינה; 4 - שגיאת הידור; 5 - שגיאת הידור; 6 - שגיאת זמן ריצה; 7 - תקינה.
שאלה 8 · מעקב אחרי פעולות על תורים
לפניכם שלוש פעולות secret, what, something הבאות:
public static int secret(Queue<Integer> q) {
Queue<Integer> temp=new Queue<Integer>();
while(!q.isEmpty()){
temp.insert(q.remove());
}
int c=0;
while(!temp.isEmpty()){
c++;
q.insert(temp.remove());
}
return c;
}
public static int what(Queue<Integer>q) {
int len = secret(q);
int temp = q.remove();
q.insert(temp);
for(int i = 0; i < len; i++){
int curr = q.remove();
q.insert(curr);
if(curr > temp)
temp = curr;
}
return temp;
}
public static boolean something(Queue<Integer> q1,
Queue<Integer> q2)
{
if(secret(q1)==0)
return false;
int temp = what(q1);
int len = secret(q2);
for(int i = 0; i < len; i++){
int curr = q2.remove();
q2.insert(curr);
if(temp <= curr)
return false;
}
return true;
}public static int Secret(Queue<int> q) {
Queue<int> temp=new Queue<int>();
while(!q.IsEmpty()){
temp.Insert(q.Remove());
}
int c=0;
while(!temp.IsEmpty()){
c++;
q.Insert(temp.Remove());
}
return c;
}
public static int What(Queue<int>q) {
int len = Secret(q);
int temp = q.Remove();
q.Insert(temp);
for(int i = 0; i < len; i++){
int curr = q.Remove();
q.Insert(curr);
if(curr > temp)
temp = curr;
}
return temp;
}
public static bool Something(Queue<int> q1, Queue<int> q2)
{
if(Secret(q1)==0)
return false;
int temp = What(q1);
int len = Secret(q2);
for(int i = 0; i < len; i++){
int curr = q2.Remove();
q2.Insert(curr);
if(temp <= curr)
return false;
}
return true;
}נתונים שלושת התורים הבאים:

עקבו אחרי זימון הפעולה secret(a) ורשמו מה תהיה תוצאת הזימון.
עקבו אחרי זימון הפעולה what(b) ורשמו מה תהיה תוצאת הזימון.
עקבו אחרי זימון הפעולה something (a ,c) ורשמו מה תהיה תוצאת הזימון.
האם קיימים שני תורים q1, q2 כך something(q1, q2) = something(q2, q1)? הסבירו.
מה מבצעות הפעולות secret, what, something?
◂ פתרון מלא לשאלה 8
סעיף א
4 (התור a נשאר 3, 1, 5, 1).
בתורים שבאיור הכניסה מימין והיציאה משמאל, כלומר ראש התור הוא האיבר השמאלי: ב-a הסדר מהראש הוא 3, 1, 5, 1.
הפעולה מעבירה את כל איברי q לתור עזר, ואז מחזירה אותם ל-q תוך ספירה:
שני התורים הם FIFO, ולכן הסדר נשמר, ו-a חוזר למצבו המקורי.
תשובה: secret(a) מחזירה 4, והתור a נשאר 3, 1, 5, 1.
סעיף ב
3 (התור b משתנה ל-1, 3, 1, 2).
התור b מהראש: 2, 1, 3, 1.
1. `len = secret(b) = 4`, והתור לא משתנה.
2. `temp = b.remove() = 2`, ומיד `b.insert(2)`. התור עכשיו: 1, 3, 1, 2.
3. הלולאה רצה 4 פעמים; בכל פעם מוציאה איבר, מחזירה אותו לסוף, ומעדכנת את temp אם האיבר גדול ממנו:
4. מוחזר temp = 3 - הערך הגדול ביותר בתור.
שימו לב: הלולאה עברה סיבוב שלם, אבל ההוצאה וההחזרה של האיבר הראשון לפני הלולאה גרמו לכך שבסוף התור מסובב באיבר אחד: 1, 3, 1, 2 במקום 2, 1, 3, 1.
תשובה: what(b) מחזירה 3, והתור b הופך ל-1, 3, 1, 2.
סעיף ג
true (המקסימום של a הוא 5, וכל איברי c שווים ל-4 < 5).
התור a מהראש: 3, 1, 5, 1. התור c: 4, 4, 4.
1. `secret(a) = 4`, שונה מ-0, ולכן ממשיכים.
2. `temp = what(a)`: לפי סעיף ב, what מחזירה את הערך הגדול ביותר, כלומר `temp = 5`. (התור a מסובב ל-1, 5, 1, 3.)
3. `len = secret(c) = 3`.
4. הלולאה עוברת על איברי c ובודקת אם `temp <= curr`:
אף איבר של c אינו גדול או שווה ל-5, והלולאה מסתיימת (התור c חוזר לסדרו המקורי).
5. מוחזר true.
תשובה: something(a, c) מחזירה true.
סעיף ד
כן. למשל q1 = q2 = c (4, 4, 4), או שני תורים ריקים: שני הזימונים מחזירים false. שני הזימונים לעולם לא יחזירו יחד true.
מה something בודקת: something(q1, q2) מחזירה true בדיוק כאשר q1 לא ריק וכל איברי q2 קטנים ממש מהמקסימום של q1. כאשר q2 לא ריק, זה שקול ל-.
האם שני הזימונים יכולים להחזיר true יחד? לא:
•אם שני התורים לא ריקים, צריך גם וגם - סתירה.
•אם אחד התורים ריק, הזימון שבו הוא הפרמטר הראשון מחזיר false.
האם שניהם יכולים להחזיר false יחד? כן, ולכן התשובה לשאלה היא כן. דוגמאות:
1. (4, 4, 4): המקסימום של q1 הוא 4, והאיבר הראשון של q2 הוא 4, ו- - false; מאותה סיבה גם הזימון ההפוך מחזיר false.
2. שני תורים ריקים: `secret(q1) == 0`, ושני הזימונים מחזירים false.
3. באופן כללי: כל שני תורים לא ריקים שהמקסימום שלהם שווה.
תשובה: כן - למשל שני תורים שווים כמו c ו-c (או שני תורים ריקים): שני הזימונים מחזירים false. שוויון אפשרי רק כששני הזימונים מחזירים false.
סעיף ה
secret - מחזירה את מספר האיברים בתור (התור לא משתנה). what - מחזירה את הערך הגדול ביותר בתור לא ריק (ומסובבת אותו באיבר אחד). something - מחזירה true אם q1 לא ריק וכל איברי q2 קטנים מהמקסימום של q1, אחרת false.
1. secret(q): מעבירה את כל איברי התור לתור עזר ומחזירה אותם, תוך ספירה. מחזירה את מספר האיברים בתור, והתור חוזר למצבו המקורי. סיבוכיות .
2. what(q): (לתור לא ריק) מאתחלת את temp לאיבר הראשון, ועוברת סיבוב שלם על התור תוך שמירת הערך הגדול ביותר. מחזירה את הערך הגדול ביותר בתור. תופעת לוואי: האיבר שהיה בראש עובר לסוף, כלומר התור מסובב באיבר אחד. סיבוכיות .
3. something(q1, q2): אם q1 ריק מחזירה false. אחרת מחשבת את המקסימום של q1 ובודקת את כל איברי q2. מחזירה true אם כל איברי q2 קטנים ממש מהערך הגדול ביותר ב-q1 (כלומר , או q2 ריק), אחרת false. סיבוכיות .
תשובה: secret - מספר האיברים בתור; what - הערך המקסימלי בתור; something - true אם q1 לא ריק וכל איברי q2 קטנים מהמקסימום של q1.
שאלה 9 · חישוב מחירי חבילות בחברת כבלים
לפניכם חלק ממערכת המטפלת בלקוחות של חברת הכבלים.
החברה מאפשרת לברור באחת משלוש חבילות: חבילה בסיסית, חבילה מורחבת וחבילה משולבת.
בקוד הבא נתונות שש מחלקות הקשורות ביניהן בקשרי הורשה (ללא הפעולות שיש בהן).
public class Cable
{
private double subscriptionPayment; // מחיר קבוע למנוי
public double getPrice()
{
return subscriptionPayment;
}
}
// חבילה בסיסית
public class BasicPackage extends Cable
{
private double price; // מחיר חבילה בסיסית
}
// חבילה מורחבת המכילה ערוצים נוספים
public class ExtendedPackage extends BasicPackage
{
private double price; // מחיר קבוע עבור כל ערוץ נוסף
private int numOfChannels;
private String[] namesOfChannels; // מערך שמות ערוצים
}
// מחלקה עבור טלפון
public class Phone extends Cable
{
private double price; // מחיר שיחה
private int numberOfCalls; // מספר שיחות
}
// חבילה משולבת
public class Triple extends Cable
{
private Cable package; // חבילה בסיסית או מורחבת
private Phone phone; // טלפון
private double priceOfInternet; // מחיר השימוש באינטרנט
}
// מחלקה עבור לקוח
public class Client
{
private String nameClient;
private Cable cable;
}public class Cable
{
private double subscriptionPayment; // מחיר קבוע למנוי
public double GetPrice()
{
return subscriptionPayment;
}
}
// חבילה בסיסית
public class BasicPackage : Cable
{
private double price; // מחיר חבילה בסיסית
}
// חבילה מורחבת המכילה ערוצים נוספים
public class ExtendedPackage : BasicPackage
{
private double price; // מחיר קבוע עבור כל ערוץ נוסף
private int numOfChannels;
private string[] namesOfChannels; // מערך שמות ערוצים
}
// מחלקה עבור טלפון
public class Phone : Cable
{
private double price; // מחיר שיחה
private int numberOfCalls; // מספר שיחות
}
// חבילה משולבת
public class Triple : Cable
{
private Cable package; // חבילה בסיסית או מורחבת
private Phone phone; // טלפון
private double priceOfInternet; // מחיר השימוש באינטרנט
}
// מחלקה עבור לקוח
public class Client
{
private string nameClient;
private Cable cable;
}הניחו שעבור כל התכונות בכל המחלקות קיימות פעולות get ו- set.
לקוח החברה יכול לרכוש מנוי לפי בחירתו. החברה קבעה שיטת מחיר לכל חבילה שהיא מספקת לפי הכללים הבאים:
•למחיר כל חבילה מתווסף גם המחיר הקבוע למנוי.
•מחיר חבילה מורחבת הוא מחיר החבילה הבסיסית + [מחיר ערוץ] * [מספר הערוצים].
•התשלום עבור שיחות הטלפון הוא [מחיר שיחה] * [מספר שיחות]
•לוקח הרוכש חבילה משולבת מקבל 10% הנחה (זאת אומרת שמחיר חבילה משולבת הוא 90% מסכום כל מרכיביו).
ממשו את פעולת getPrice בכל אחת מארבע המחלקות האחרות:
BasicPackage, ExtendedPackage,Phone, Triple.
ממשו את הפעולה getPrice במחלקה: Client
נתונה מחלקה "חברת הכבלים" Company המכילה מערך clients מטיפוס Client בגודל 1000 ומונה לקוחות numClients.
כתבו במחלקה Company את הפעולות הבאות:
הפעולה המדפיסה את שמות הלקוחות שיש להם ערוץ "ספורט".
הפעולה המחזירה את כמות הלקוחות שיש להם חבילה בסיסית בלבד.
◂ פתרון מלא לשאלה 9
סעיף א
BasicPackage: super.getPrice() + price; ExtendedPackage: super.getPrice() + price*numOfChannels; Phone: super.getPrice() + price*numberOfCalls; Triple: 0.9*(super.getPrice() + package.getPrice() + phone.getPrice() + priceOfInternet); Client: cable.getPrice().
הרעיון: כל מחלקה דורסת את getPrice ומשתמשת ב-`super.getPrice()` (ב-C#: `base.GetPrice()`) כדי לקבל את החלק של המחיר שמחלקת העל כבר יודעת לחשב. כך כל כלל מחיר נכתב פעם אחת בלבד:
1. Cable מחזירה את המחיר הקבוע למנוי. כל מחלקה שיורשת ממנה מקבלת אותו דרך `super.getPrice()`, וכך מתקיים הכלל "למחיר כל חבילה מתווסף המחיר הקבוע למנוי".
2. BasicPackage: מנוי + מחיר החבילה הבסיסית: `super.getPrice() + price`.
3. ExtendedPackage: לפי הכלל - מחיר החבילה הבסיסית (כולל המנוי) ועוד מחיר ערוץ כפול מספר הערוצים. התכונה price של BasicPackage פרטית, ובנוסף ExtendedPackage מגדירה price משלה (מחיר ערוץ), ולכן את מחיר החבילה הבסיסית מקבלים רק דרך `super.getPrice()`: `super.getPrice() + price * numOfChannels`.
4. Phone: מנוי + מחיר שיחה כפול מספר השיחות.
5. Triple: סכום כל המרכיבים - המנוי של החבילה, מחיר החבילה הבסיסית או המורחבת, מחיר הטלפון ומחיר האינטרנט - כפול 0.9 (הנחה של 10%). מחיר החבילה והטלפון מחושבים בזימון getPrice שלהם, והקישור הדינמי בוחר את הגרסה המתאימה (בסיסית או מורחבת) לפי הסוג האמיתי של העצם.
6. Client: אינה יורשת מ-Cable. היא מחזירה את המחיר של המנוי שלה: `cable.getPrice()` - הקישור הדינמי מפעיל את getPrice של הסוג האמיתי של המנוי.
הערות:
•ב-Java המילה `package` היא מילה שמורה, ולכן תכונה בשם זה לא תעבור הידור. בקוד הפתרון ניגשים לחבילה דרך הפעולה `getPackage()`, שקיימת לפי ההנחה בשאלה (בפועל יש לשנות את שם התכונה, למשל ל-`pack`).
•ב-C# כדי שהקישור הדינמי יפעל, GetPrice של Cable צריכה להיות מוגדרת `virtual`, והפעולות במחלקות היורשות `override`.
// במחלקה BasicPackage
public double getPrice()
{
return super.getPrice() + this.price;
}
// במחלקה ExtendedPackage
public double getPrice()
{
return super.getPrice() + this.price * this.numOfChannels;
}
// במחלקה Phone
public double getPrice()
{
return super.getPrice() + this.price * this.numberOfCalls;
}
// במחלקה Triple
public double getPrice()
{
double sum = super.getPrice() + this.getPackage().getPrice()
+ this.getPhone().getPrice() + this.priceOfInternet;
return 0.9 * sum;
}
// במחלקה Client
public double getPrice()
{
return this.cable.getPrice();
}// במחלקה Cable הפעולה מוגדרת וירטואלית:
// public virtual double GetPrice()
// במחלקה BasicPackage
public override double GetPrice()
{
return base.GetPrice() + this.price;
}
// במחלקה ExtendedPackage
public override double GetPrice()
{
return base.GetPrice() + this.price * this.numOfChannels;
}
// במחלקה Phone
public override double GetPrice()
{
return base.GetPrice() + this.price * this.numberOfCalls;
}
// במחלקה Triple
public override double GetPrice()
{
double sum = base.GetPrice() + this.package.GetPrice()
+ this.phone.GetPrice() + this.priceOfInternet;
return 0.9 * sum;
}
// במחלקה Client
public double GetPrice()
{
return this.cable.GetPrice();
}דוגמה מספרית: מנוי 50, חבילה בסיסית 100, ערוץ נוסף 10 עם 3 ערוצים, שיחה 0.5 עם 40 שיחות, אינטרנט 80, ולחבילה המשולבת עצמה מנוי 0:
•חבילה בסיסית: .
•חבילה מורחבת: .
•טלפון: .
•חבילה משולבת (עם המורחבת): .
תשובה: הפעולות getPrice שלמעלה.
סעיף ב
לכל לקוח: לוקחים את המנוי; אם הוא Triple - עוברים לחבילה שבתוכו; אם החבילה היא ExtendedPackage מחפשים במערך שמות הערוצים את "ספורט", ואם נמצא מדפיסים את שם הלקוח.
הרעיון: ערוצים (ושמות ערוצים) יש רק בחבילה מורחבת. לקוח יכול להחזיק חבילה מורחבת בשתי דרכים: ישירות, או בתוך חבילה משולבת (התכונה package של Triple). לכן לכל לקוח:
1. לוקחים את המנוי שלו `c = clients[i].getCable()`.
2. אם `c` הוא Triple - מחליפים אותו בחבילה שבתוכו (`getPackage()`).
3. אם `c` הוא ExtendedPackage (בדיקת `instanceof` / `is`) - ממירים, לוקחים את מערך שמות הערוצים ומחפשים בו "ספורט" (השוואת מחרוזות עם `equals` ב-Java). החיפוש נעצר ברגע שנמצא.
4. אם נמצא - מדפיסים את שם הלקוח.
עוברים רק על `numClients` הלקוחות הראשונים, כי שאר תאי המערך ריקים. הסיבוכיות: , כאשר k מספר הערוצים המרבי.
public void printSportClients()
{
for (int i = 0; i < this.numClients; i++)
{
Cable c = this.clients[i].getCable();
if (c instanceof Triple) // ערוצים יש רק בחבילה שבתוך החבילה המשולבת
c = ((Triple) c).getPackage();
if (c instanceof ExtendedPackage)
{
String[] names = ((ExtendedPackage) c).getNamesOfChannels();
boolean found = false;
for (int k = 0; k < names.length && !found; k++)
if (names[k] != null && names[k].equals("ספורט"))
found = true;
if (found)
System.out.println(this.clients[i].getNameClient());
}
}
}public void PrintSportClients()
{
for (int i = 0; i < this.numClients; i++)
{
Cable c = this.clients[i].GetCable();
if (c is Triple) // ערוצים יש רק בחבילה שבתוך החבילה המשולבת
c = ((Triple)c).GetPackage();
if (c is ExtendedPackage)
{
string[] names = ((ExtendedPackage)c).GetNamesOfChannels();
bool found = false;
for (int k = 0; k < names.Length && !found; k++)
if (names[k] != null && names[k] == "ספורט")
found = true;
if (found)
Console.WriteLine(this.clients[i].GetNameClient());
}
}
}תשובה: הפעולה `printSportClients` / `PrintSportClients` שלמעלה.
סעיף ג
סופרים לקוחות שהמנוי שלהם הוא BasicPackage אבל לא ExtendedPackage (instanceof BasicPackage && !(instanceof ExtendedPackage)).
הרעיון: "חבילה בסיסית בלבד" - המנוי של הלקוח הוא עצם מסוג BasicPackage עצמה: לא חבילה מורחבת, ולא חבילה משולבת שמכילה חבילה בסיסית.
הקושי: ExtendedPackage יורשת מ-BasicPackage, ולכן עבור חבילה מורחבת גם `c instanceof BasicPackage` מחזיר true. לכן התנאי הוא:
•`c instanceof BasicPackage` - המנוי הוא חבילה בסיסית או מורחבת;
•וגם `!(c instanceof ExtendedPackage)` - הוא לא מורחבת.
חבילה משולבת (Triple) וטלפון (Phone) אינם BasicPackage, ולכן לא נספרים.
עוברים על `numClients` הלקוחות, סופרים את המקיימים את התנאי ומחזירים את המונה. סיבוכיות .
public int countBasicOnly()
{
int count = 0;
for (int i = 0; i < this.numClients; i++)
{
Cable c = this.clients[i].getCable();
if (c instanceof BasicPackage && !(c instanceof ExtendedPackage))
count++;
}
return count;
}public int CountBasicOnly()
{
int count = 0;
for (int i = 0; i < this.numClients; i++)
{
Cable c = this.clients[i].GetCable();
if (c is BasicPackage && !(c is ExtendedPackage))
count++;
}
return count;
}תשובה: הפעולה `countBasicOnly` / `CountBasicOnly` שלמעלה.
שאלה 10 · מערך רשימות של חשבוניות תדלוק
חברת הובלות TrickTruck מעוניינת לעקוב אחרי תצרוכת הדלק של כל אחד כלי הרכב שהיא מפעילה, במשך התקופה של חודש יוני (30 יום).
כל נהג מתדלק מביא לתחנה חשבונית המכילה את הפרטים הבאים:
•יום התדלוק (מספר שלם בין 1-30).
•מספר רכב (מספר שלם).
•שם הנהג המתדלק (מחרוזת).
•כמות הדלק שתודלקה בתדלוק זה (מספר ממשי).
במחלקת חשבונית Payment הוגדרו פעולות הבאות:
•פעולה בונה היוצרת חשבונית הכוללת את שם הנהג name את מספר הרכב num ואת כמות הדלק שתידלק fuel.
Payment (String name, int num, double fuel)
•פעולות get ו- set – לכל תכונה והפעולה toString המחזירה מחרוזת המתארת את מצב החשבונית.
המידע עבור כל התדלוקים בחודש אפריל נשמר במחלקה TrickTruck במערך חד-ממדי payments של רשימות מסוג חשבונית, Payment. כל תא במערך מייצג יום תדלוק. שתי תכונות נוספות הן רשימת הנהגים drivers, ורשימת הרכבים cars:
class TrickTrack
{
private Node<String> drivers;
private Node<Integer> cars;
private Node<Payment>[] payments;
… .class TrickTrack
{
private Node<string> drivers;
private Node<int> cars;
private Node<Payment>[] payments;במחלקה הוגדרו פעולה בונה, פעולות get/set.
במחלקה הוגדרו שלוש פעולות בוליאניות נוספות:
•existDriver(String name) – הפעולה מחזירה true אם הנהג name עבד בחודש יוני, ואם לא הפעולה מחזירה false.
•existCar(int num) – הפעולה מחזירה true אם הרכב num עבד בחודש יוני, ואם לא הפעולה מחזירה false.
•worked(String name, int day) – הפעולה מחזירה true אם נהג name הגיש קבלת תשלום ביום day, ואם לא, הפעולה תחזיר false.
כתבו פעולה במחלקה TrickTruck בשם addPayment שתקבל כפרמטר את היום בחודש day, את מספר הרכב num, את שם הנהג name ואת כמות הדלק fuel שתדלק.
אם כל הפרמטרים שהפעולה מקבלת הם תקינים, הפעולה מוסיפה חשבונית חדשה לרשימה המתאימה במערך payments ומחזירה true, ואם לא הפעולה מחזירה false, ולא מבצעת דבר.
כתבו במחלקה TrickTruck את הפעולה totalFuel(int num) המקבלת מספר רכב ומחזירה את כמות הדלק הכללית שתדלקו את הרכב.
כתבו במחלקה TrickTruck את הפעולה printWorkDays() המדפיסה עבור כל נהג את מספר הימים שעבורם הוא הציג קבלות.
◂ פתרון מלא לשאלה 10
סעיף א
בודקים 1 ≤ day ≤ 30 (אורך המערך), existCar(num), existDriver(name) ו-fuel > 0; אם תקין - יוצרים Payment ומוסיפים חוליה בראש הרשימה payments[day-1] ומחזירים true, אחרת false.
נתון: יום, מספר רכב, שם נהג וכמות דלק.
מבוקש: להוסיף חשבונית לרשימה של אותו יום, רק אם הנתונים תקינים.
1. היום בטווח 1 עד 30. המערך payments מכיל תא לכל יום, והיום day נשמר בתא שהאינדקס שלו `day - 1` (אינדקסים 0 עד 29), ולכן בודקים `1 <= day <= payments.length`.
2. הרכב קיים בחברה - `existCar(num)`.
3. הנהג קיים בחברה - `existDriver(name)`.
4. כמות הדלק חיובית - `fuel > 0`.
אם אחד התנאים לא מתקיים - מחזירים false ולא משנים דבר.
ההוספה: יוצרים עצם Payment חדש, ומוסיפים חוליה חדשה בראש הרשימה של אותו יום (הסדר בתוך היום לא חשוב, והוספה בראש היא ; היא עובדת גם כשהרשימה ריקה, null). אין צורך לבדוק אם הרכב כבר תודלק באותו יום, כי רכב יכול להיות מתודלק כמה פעמים ביום.
public boolean addPayment(int day, int num, String name, double fuel)
{
if (day < 1 || day > this.payments.length || !existCar(num)
|| !existDriver(name) || fuel <= 0)
return false;
Payment p = new Payment(name, num, fuel);
this.payments[day - 1] = new Node<Payment>(p, this.payments[day - 1]);
return true;
}public bool AddPayment(int day, int num, string name, double fuel)
{
if (day < 1 || day > this.payments.Length || !ExistCar(num)
|| !ExistDriver(name) || fuel <= 0)
return false;
Payment p = new Payment(name, num, fuel);
this.payments[day - 1] = new Node<Payment>(p, this.payments[day - 1]);
return true;
}תשובה: הפעולה `addPayment` / `AddPayment` שלמעלה.
סעיף ב
סוכמים את fuel של כל החשבוניות שבהן getNum() == num, על פני כל התאים במערך payments וכל החוליות בכל רשימה.
הרעיון: החשבוניות של הרכב מפוזרות בכל ימי החודש, ובכל יום ייתכנו כמה חשבוניות שלו (או אף אחת). לכן צריך מעבר כפול:
1. לולאה חיצונית על כל תאי המערך (כל הימים).
2. לולאה פנימית על כל החוליות ברשימה של אותו יום.
3. לכל חשבונית שמספר הרכב שלה שווה ל-num - מוסיפים את כמות הדלק שלה לצובר.
4. מחזירים את הצובר (0 אם הרכב לא תודלק כלל).
כל חשבונית נבדקת פעם אחת: סיבוכיות , כאשר P מספר החשבוניות בחודש.
public double totalFuel(int num)
{
double sum = 0;
for (int d = 0; d < this.payments.length; d++)
{
Node<Payment> p = this.payments[d];
while (p != null)
{
if (p.getValue().getNum() == num)
sum += p.getValue().getFuel();
p = p.getNext();
}
}
return sum;
}public double TotalFuel(int num)
{
double sum = 0;
for (int d = 0; d < this.payments.Length; d++)
{
Node<Payment> p = this.payments[d];
while (p != null)
{
if (p.GetValue().GetNum() == num)
sum += p.GetValue().GetFuel();
p = p.GetNext();
}
}
return sum;
}דוגמה: אם הרכב 11 תודלק ב-40 ליטר וב-10 ליטר ביום 1, וב-5.5 ליטר ביום 30, יוחזר .
תשובה: הפעולה `totalFuel` / `TotalFuel` שלמעלה.
סעיף ג
לכל נהג ברשימה drivers סופרים את הימים day = 1..30 שעבורם worked(name, day) מחזירה true, ומדפיסים את השם ואת המספר.
הרעיון: הפעולה הנתונה `worked(name, day)` כבר עונה על השאלה "האם הנהג הציג קבלה ביום day". לכן לכל נהג פשוט סופרים בכמה ימים היא מחזירה true:
1. עוברים על רשימת הנהגים drivers.
2. לכל נהג מאפסים מונה, ועוברים על הימים 1 עד 30 (אורך המערך).
3. לכל יום שבו `worked(name, day)` מחזירה true - מגדילים את המונה. כך נהג שהציג כמה קבלות באותו יום נספר פעם אחת לאותו יום, כנדרש ("מספר הימים").
4. מדפיסים את שם הנהג ואת מספר הימים, ועוברים לנהג הבא.
public void printWorkDays()
{
Node<String> p = this.drivers;
while (p != null)
{
String name = p.getValue();
int days = 0;
for (int day = 1; day <= this.payments.length; day++)
if (worked(name, day))
days++;
System.out.println(name + " " + days);
p = p.getNext();
}
}public void PrintWorkDays()
{
Node<string> p = this.drivers;
while (p != null)
{
string name = p.GetValue();
int days = 0;
for (int day = 1; day <= this.payments.Length; day++)
if (Worked(name, day))
days++;
Console.WriteLine(name + " " + days);
p = p.GetNext();
}
}תשובה: הפעולה `printWorkDays` / `PrintWorkDays` שלמעלה.
שאלה 11 · תרשים UML ומעקב אחרי בנאים ופולימורפיזם
לפניכם ארבע מחלקות:
class A
{
private static int countA = 0;
protected int n;
public A(int n1)
{
this.n = n1;
A.countA++;
System.out.println(A.countA + " " + this.n);
}
public int getN()
{
return this.n;
}
public void doIt()
{
for (int i = 0; i < this.n; i++)
System.out.print (i + ",");
System.out.println();
}
public void print()
{
System.out.println (this.n);
}
}
class B extends A
{
private static int countB = 0;
public B(int n2)
{
super(n2);
B.countB++;
System.out.println (B.countB +" " + n2);
}
public void doIt()
{
System.out.println ("B Does It!");
}
}
class C extends B
{
private static int countC = 0;
private A a;
public C(int n1, int n2)
{
super(n1);
this.a = new A(n2);
countC++;
System.out.println ("C is " + (a.getN() + this.n));
}
public void print()
{
super.print();
this.a.print();
}
}
class Test
{
private A[] arr;
public Test()
{
arr = new A[3];
arr[0] = new A(4);
arr[1] = new B(2);
arr[2] = new C(1, 6);
}
public void testIt()
{
for (int i = 0; i < arr.length; i++)
{
arr[i].doIt();
arr[i].print();
}
}
}class A
{
private static int countA = 0;
protected int n;
public A(int n1)
{
this.n = n1;
A.countA++;
Console.WriteLine(A.countA + " " + this.n);
}
public int GetN()
{
return this.n;
}
public virtual void DoIt()
{
for (int i = 0; i < this.n; i++)
Console.Write (i + ",");
Console.WriteLine();
}
public virtual void Print()
{
Console.WriteLine (this.n);
}
}
class B : A
{
private static int countB = 0;
public B(int n2): base(n2)
{
B.countB++;
Console.WriteLine (B.countB +" " + n2);
}
public override void DoIt()
{
Console.WriteLine ("B Does It!");
}
}
class C : B
{
private static int countC = 0;
private A a;
public C(int n1, int n2):base(n1)
{
this.a = new A(n2);
countC++;
Console.WriteLine("C is " + (a.GetN() + this.n));
}
public override void Print()
{
base.Print();
this.a.Print();
}
}
class Test
{
private A[] arr;
public Test()
{
arr = new A[3];
arr[0] = new A(4);
arr[1] = new B(2);
arr[2] = new C(1, 6);
}
public void TestIt()
{
for (int i = 0; i < arr.Length; i++)
{
arr[i].DoIt();
arr[i].Print();
}
}
}בנו תרשים מחלקות UML (הכולל קשרים) עבור ארבע המחלקות המוצגות בשאלה.
על התרשים לכלול את שמות המחלקות ואת הקשרים ביניהם.
לפניכם קטע קוד:
public static void main(String[] args)
{
Test test = new Test();
test.testIt();
}public static void Main(string[] args)
{
Test test = new Test();
test.TestIt();
}עבור קטע קוד זה בצעו והציגו את פלט הקטע. חובה להציג מעקב.
◂ פתרון מלא לשאלה 11
סעיף א
ירושה: B יורשת מ-A, C יורשת מ-B. הכלה (aggregation/composition): ל-C יש תכונה a מסוג A (C מכילה A אחד); ל-Test יש מערך arr של A (Test מכילה 3 עצמי A).
שני סוגי קשרים מופיעים בקוד:
1. ירושה (is-a) - מסומנת בחץ עם ראש משולש ריק, מהמחלקה היורשת אל מחלקת העל:
•`class B extends A` (ב-C#: `B : A`) - B יורשת מ-A.
•`class C extends B` - C יורשת מ-B (ולכן בעקיפין גם מ-A).
2. הכלה (has-a) - קו עם מעוין בצד המחלקה המכילה:
•ב-C התכונה `private A a` - לכל עצם C יש עצם A אחד (C יוצרת אותו בבנאי שלה, ולכן אפשר לסמן הרכבה - מעוין מלא - עם ריבוי 1).
•ב-Test התכונה `private A[] arr` - עצם Test מכיל מערך של עצמי A (בפועל 3, שנוצרים בבנאי של Test), ריבוי 3 (או `*`).
(`-` פרטי, `#` מוגן, `+` ציבורי.)
B ----|> A (B extends A)
C ----|> B (C extends B)
C <>---- A 1 (C.a)
Test <>---- A 3 (Test.arr)כלומר: B ▷ A (ירושה), C ▷ B (ירושה), C ◆ A (הכלה, 1), Test ◇ A (הכלה, 3).
תשובה: B יורשת מ-A, C יורשת מ-B; C מכילה עצם A אחד (התכונה a), ו-Test מכילה מערך של 3 עצמי A (התכונה arr).
סעיף ב
פלט (שורה אחרי שורה): 1 4 / 2 2 / 1 2 / 3 1 / 2 1 / 4 6 / C is 7 / 0,1,2,3, / 4 / B Does It! / 2 / B Does It! / 1 / 6
שני שלבים: בניית העצם `test` (הבנאים מדפיסים), ואחר כך `testIt()`.
•בנאי של מחלקה יורשת מפעיל קודם את בנאי מחלקת העל (`super(...)` / `base(...)`), ורק אחר כך ממשיך בגוף שלו.
•המונים `countA`, `countB`, `countC` סטטיים - משותפים לכל העצמים של המחלקה. `countA` גדל בכל בנייה של A, כולל כחלק מבנייה של B או C, וכולל העצם A שנוצר בתוך C.
•בזימון `arr[i].doIt()` ו-`arr[i].print()` מופעלת הגרסה של הטיפוס האמיתי של העצם (קישור דינמי).
1 4
2 2
1 2
3 1
2 1
4 6
C is 7
0,1,2,3,
4
B Does It!
2
B Does It!
1
6תשובה: הפלט הוא 14 השורות שלמעלה: 1 4, 2 2, 1 2, 3 1, 2 1, 4 6, C is 7, 0,1,2,3, , 4, B Does It!, 2, B Does It!, 1, 6.