מדעי המחשב ב`

Transcription

מדעי המחשב ב`
‫מדינת ישרא ל‬
‫א‪ .‬בגרות לבתי ספר על־יסודיים‬
‫סוג הבחינה‪:‬‬
‫ב‪ .‬בגרות לנבחנים חיצוניים‬
‫‬
‫מועד הבחינה‪ :‬קיץ תשע"א‪2011 ,‬‬
‫‬
‫מספר השאלון‪603 ,899205 :‬‬
‫משרד החינוך‬
‫‬
‫‬
‫מ ד ע י ה מ ח ש ב ב'‬
‫‪ 2‬יחידות לימוד (השלמה ל–‪ 5‬יח"ל)‬
‫הוראות לנבחן‬
‫א‪.‬‬
‫משך הבחינה‪ :‬שלוש שעות‪.‬‬
‫ב‪ .‬מבנה השאלון ומפתח ההערכה‪ :‬בשאלון זה שני פרקים‪.‬‬
‫— (‪ 5 0 — )25x2‬נקודות‬
‫‬
‫פרק ראשון — בפרק זה ארבע שאלות‪,‬‬
‫‬
‫ומהן יש לענות על שתיים‪.‬‬
‫‬
‫‬
‫— בפרק זה שאלות בארבעה מסלולים שונים — (‪ 50 — )25x2‬נקודות‬
‫פרק שני‬
‫‬
‫ענה על שאלות רק במסלול שלמדת‪,‬‬
‫‬
‫לפי ההוראות בקבוצת השאלות במסלול זה‪.‬‬
‫‬
‫סה"כ — ‪ 100‬נקודות‬
‫‬
‫ג‪.‬‬
‫חומר עזר מותר בשימוש‪ :‬כל חומר עזר‪ ,‬חוץ ממחשב הניתן לתכנות‪.‬‬
‫ד‪ .‬הוראות מיוחדות‪:‬‬
‫(‪ )1‬את כל התכניות שאתה נדרש לכתוב בשפת מחשב בפרק הראשון‬
‫‬
‫כתוב בשפה אחת בלבד — ‪ C#‬או ‪. Java‬‬
‫‬
‫(‪ )2‬רשֹום על הכריכה החיצונית של המחברת באיזו שפה אתה כותב — ‪ C#‬או ‪. Java‬‬
‫‬
‫(‪ )3‬רשֹום על הכריכה החיצונית של המחברת את שם המסלול שלמדת‪,‬‬
‫‬
‫אחד מארבעת המסלולים‪ :‬מערכות מחשב ואסמבלר‪ ,‬מבוא לחקר ביצועים‪,‬‬
‫‬
‫מודלים חישוביים‪ ,‬תכנות מונחה עצמים‪.‬‬
‫‬
‫הערה‪ :‬בתכניות שאתה כותב לא יּורדּו לך נקודות‪ ,‬אם תכתוב אות גדולה במקום‬
‫‬
‫אות קטנה או להפך‪.‬‬
‫‬
‫כתוב במחברת הבחינה בלבד‪ ,‬בעמודים נפרדים‪ ,‬כל מה שברצונך לכתוב כטיוטה (ראשי פרקים‪ ,‬חישובים וכדומה)‪.‬‬
‫רשֹום "טיוטה" בראש כל עמוד טיוטה‪ .‬רישום טיוטות כלשהן על דפים שמחוץ למחברת הבחינה עלול לגרום לפסילת הבחינה!‬
‫ההנחיות בשאלון זה מנוסחות בלשון זכר ומכוונות לנבחנות ולנבחנים כאחד‪.‬‬
‫בהצלחה!‬
‫‪/‬המשך מעבר לדף‪/‬‬
‫‪--‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫השאלות‬
‫בשאלון זה שני פרקים‪ :‬פרק ראשון ופרק שני‪.‬‬
‫עליך לענות על שאלות משני הפרקים‪ ,‬לפי ההוראות בכל פרק‪.‬‬
‫פרק ראשון‬
‫(‪ 50‬נקודות)‬
‫שים לב‪ :‬בכל שאלה שנדרש בה מימוש אתה יכול להשתמש בפעולות של‬
‫המחלקות >‪, BinTreeNode<T> ,Stack<T> , Queue<T> , Node<T‬‬
‫בלי לממש אותן‪ .‬אם אתה משתמש בפעולות נוספות עליך לממש אותן‪.‬‬
‫ענה על שתיים מהשאלות ‪( 4-1‬לכל שאלה — ‪ 25‬נקודות)‪.‬‬
‫שים לב‪ :‬לשאלה זו שני נוסחים‪ :‬אחד ב– ‪( Java‬עמודים ‪ ,)3-2‬ואחד ב– ‪C#‬‬
‫‪.1‬‬
‫(עמודים ‪ .)5-4‬עבוד על פי השפה שלמדת‪.‬‬
‫לפותרים ב– ‪Java‬‬
‫א‪.‬‬
‫‬
‫}‬
‫לפניך כמה מחלקות‪ .‬עקוב אחר הפעולה ‪ main‬שבמחלקה ‪ Program‬ורשום את הפלט‪.‬‬
‫במעקב יש לכלול את ערכי המשתנים‪ ,‬ובעבור כל עצם — את ערכי התכונות שלו‪.‬‬
‫} ;‪this.n = n‬‬
‫};‪return this.n‬‬
‫} ;)" ‪System.out.println("f of one‬‬
‫;))(‪System.out.println("g of one " + this.getN‬‬
‫‪public class One‬‬
‫{‬
‫‬
‫;‪private double n‬‬
‫‬
‫{ )‪public One(double n‬‬
‫‬
‫{ )(‪public double getN‬‬
‫‬
‫)(‪public void f‬‬
‫{‬
‫‬
‫)(‪public void g‬‬
‫{‬
‫}‬
‫‪public class Two‬‬
‫{‬
‫‬
‫;‪private Queue<One> q‬‬
‫‬
‫)‪public Two(int n , int m‬‬
‫‬
‫{‬
‫‬
‫;)(>‪this.q = new Queue<One‬‬
‫‬
‫)‪for (int i = n; i < m; i++‬‬
‫‬
‫;)))‪this.q.insert(new One(Math.pow(2 , i‬‬
‫‬
‫}‬
‫‬
‫)(‪public void f‬‬
‫‬
‫{‬
‫‬
‫;)" ‪System.out.print("f of two‬‬
‫‬
‫))(‪if (!this.q.isEmpty‬‬
‫‬
‫;))(‪System.out.println(this.q.remove().getN‬‬
‫‬
‫}‬
‫}‬
‫‪/‬המשך בעמוד ‪/3‬‬
603 ,899205 '‫ מס‬,‫ קיץ תשע"א‬,'‫מדעי המחשב ב‬
--
public class Together
{
private double x;
private int from , to;
private One first;
private Two second;
public Together(double x , int from , int to)
{
this.x = x;
this.from = from;
this.to = to;
this.first = new One(x);
this.second = new Two(from , to);
}
public void methodA()
{
System.out.println("-- MethodA() -- ");
this.first.f();
}
public void methodB()
{
System.out.println("-- MethodB() -- ");
this.first.g();
this.second.f();
}
}
public class Program
{
public static void main(String[] args)
{
Together tg = new Together(5.0 , 2 , 6);
tg.methodA() ;
tg.methodB() ;
}
}
— ‫ בלבד‬0 –‫ מקבלת מספרים גדולים מ‬Together ‫בהנחה כי הפעולה הבונה במחלקה‬
? Two ‫ במחלקה‬f() ‫מה מבצעת הפעולה‬
/4 ‫המשך בעמוד‬/
.‫ב‬
603 ,899205 '‫ מס‬,‫ קיץ תשע"א‬,'‫מדעי המחשב ב‬
--
C# –‫לפותרים ב‬
.‫ ורשום את הפלט‬Program ‫ שבמחלקה‬Main ‫ עקוב אחר הפעולה‬.‫לפניך כמה מחלקות‬
.‫ ובעבור כל עצם — את ערכי התכונות שלו‬,‫במעקב יש לכלול את ערכי המשתנים‬
public class One
{
private double n;
public One(double n) {
public double GetN() {
public void F()
{
public void G()
{
}
this.n = n; }
return this.n;}
Console.WriteLine("F of one "); }
Console.WriteLine("G of one " + this.GetN()); }
public class Two
{
private Queue<One> q;
public Two(int n , int m)
{
this.q = new Queue<One>();
for (int i = n; i < m; i++)
this.q.Insert(new One(Math.Pow(2 , i)));
}
public void F()
{
Console.Write("F of two ");
if (!this.q.IsEmpty())
Console.WriteLine(this.q.Remove().GetN());
}
}
/5 ‫המשך בעמוד‬/
.‫א‬
603 ,899205 '‫ מס‬,‫ קיץ תשע"א‬,'‫מדעי המחשב ב‬
public class Together
{
private double x;
private int from , to;
private One first;
private Two second;
--
public Together(double x , int from , int to)
{
this.x = x;
this.from = from;
this.to = to;
this.first = new One(x);
this.second = new Two(from , to);
}
public void MethodA()
{
Console.WriteLine("-- MethodA() -- ");
this.first.F();
}
public void MethodB()
{
Console.WriteLine("-- MethodB() -- ");
this.first.G();
this.second.F();
}
}
public class Program
{
public static void Main(string[] args)
{
Together tg = new Together(5.0 , 2 , 6);
tg.MethodA();
tg.MethodB();
}
}
— ‫ בלבד‬0 –‫ מקבלת מספרים גדולים מ‬Together ‫בהנחה כי הפעולה הבונה במחלקה‬
.‫ב‬
? Two ‫ במחלקה‬F() ‫מה מבצעת הפעולה‬
/6 ‫המשך בעמוד‬/
603 ,899205 '‫ מס‬,‫ קיץ תשע"א‬,'‫מדעי המחשב ב‬
--
C# –‫ ואחד ב‬,)7-6 ‫ (עמודים‬Java –‫ אחד ב‬:‫ לשאלה זו שני נוסחים‬:‫שים לב‬
.2
,‫ ממוין בסדר עולה‬,‫ שאיבריו מטיפוס שלם‬a ‫ המקבלות מערך‬what –‫ ו‬sod ‫לפניך הפעולות‬
. k ‫ומספר שלם‬
.‫לשתי הפעולות אותה טענת יציאה‬
.‫ עבוד על פי השפה שלמדת‬.)9-8 ‫(עמודים‬
Java –‫לפותרים ב‬
public static boolean sod(int[] a , int k)
{
for (int i = 0; i < a.length-1; i++)
{
int j = i+1;
while (j < a.length)
{
if (a[i] + a[j] == k)
return true;
j++;
}
}
return false;
}
public static boolean what(int[] a , int k)
{
int left = 0 , right = a.length-1;
while (left < right)
{
if (a[left] + a[right] == k)
return true;
if (a[left] + a[right] < k)
left++;
else
right--;
}
return false;
}
/7 ‫המשך בעמוד‬/
‫‪-‬‬‫נתון מערך ‪: a‬‬
‫א‪.‬‬
‫‪12 18‬‬
‫‪7‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫‪4‬‬
‫‪2‬‬
‫‪a‬‬
‫עקוב בעזרת טבלת מעקב אחר ביצוע הפעולה ‪ sod‬בעבור המערך הנתון ‪a‬‬
‫והמספר ‪ . k = 11‬רשום את הערך המוחזר‪.‬‬
‫בטבלת המעקב יש לכלול עמודות בעבור‪ , i , j , a[i] , a[j] :‬ועמודה נוספת שבה‬
‫יצוין אם התנאי שבפקודת ‪ if‬מתקיים או אינו מתקיים‪.‬‬
‫ב‪.‬‬
‫עקוב בעזרת טבלת מעקב אחר ביצוע הפעולה ‪ sod‬בעבור המערך הנתון ‪a‬‬
‫והמספר ‪ . k = 10‬רשום את הערך המוחזר‪.‬‬
‫בטבלת המעקב יש לכלול את העמודות שפורטו בסעיף א‪.‬‬
‫ג‪.‬‬
‫מהי טענת היציאה של הפעולה ‪? sod‬‬
‫ד‪.‬‬
‫מהי סיבוכיות זמן הריצה של הפעולה ‪ ? sod‬נמק את תשובתך‪.‬‬
‫ה‪.‬‬
‫עקוב בעזרת טבלת מעקב אחר ביצוע הפעולה ‪ what‬בעבור המערך הנתון ‪a‬‬
‫והמספר ‪ . k = 11‬רשום את הערך המוחזר‪.‬‬
‫בטבלת המעקב יש לכלול עמודות בעבור‪, left, right, a[left], a[right] :‬‬
‫ושתי עמודות נוספות לכל אחת מפקודות ‪ . if‬בכל עמודה יצוין אם התנאי בפקודת‬
‫‪ if‬מתקיים או אינו מתקיים‪.‬‬
‫ו‪.‬‬
‫מהי סיבוכיות זמן הריצה של הפעולה ‪ ? what‬נמק את תשובתך‪.‬‬
‫ז‪.‬‬
‫מי מבין שתי הפעולות — ‪ sod‬או ‪ — what‬יעילה יותר? נמק את תשובתך‪.‬‬
‫ח‪.‬‬
‫טענת הכניסה של הפעולות ‪ sod‬ו– ‪ what‬שונתה כך שאפשר להעביר אליהן‬
‫‬
‫מערך ‪ a‬לא ממוין‪.‬‬
‫‬
‫(‪ )1‬האם טענת היציאה של הפעולה ‪ sod‬תשתנה? נמק את תשובתך‪.‬‬
‫‬
‫(‪ )2‬האם טענת היציאה של הפעולה ‪ what‬תשתנה? נמק את תשובתך‪.‬‬
‫‪/‬המשך בעמוד ‪/8‬‬
603 ,899205 '‫ מס‬,‫ קיץ תשע"א‬,'‫מדעי המחשב ב‬
-C# –‫לפותרים ב‬
‫ ממוין בסדר‬,‫ שאיבריו מטיפוס שלם‬a ‫ המקבלות מערך‬What –‫ ו‬Sod ‫לפניך הפעולות‬
. k ‫ ומספר שלם‬,‫עולה‬
.‫לשתי הפעולות אותה טענת יציאה‬
public static bool Sod(int[] a , int k)
{
for (int i = 0; i < a.Length-1; i++)
{
int j = i+1;
while (j < a.Length)
{
if (a[i] + a[j] == k)
return true;
j++;
}
}
return false;
}
public static bool What(int[] a , int k)
{
int left = 0 , right = a.Length-1;
while (left < right)
{
if (a[left] + a[right] == k)
return true;
if (a[left] + a[right] < k)
left++;
else
right--;
}
return false;
}
/9 ‫המשך בעמוד‬/
‫‪-‬‬‫נתון מערך ‪: a‬‬
‫א‪.‬‬
‫‪12 18‬‬
‫‪7‬‬
‫‪4‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫‪2‬‬
‫‪a‬‬
‫עקוב בעזרת טבלת מעקב אחר ביצוע הפעולה ‪ Sod‬בעבור המערך הנתון ‪a‬‬
‫והמספר ‪ . k = 11‬רשום את הערך המוחזר‪.‬‬
‫בטבלת המעקב יש לכלול עמודות בעבור‪ , i , j , a[i] , a[j] :‬ועמודה נוספת שבה‬
‫יצוין אם התנאי שבפקודת ‪ if‬מתקיים או אינו מתקיים‪.‬‬
‫ב‪.‬‬
‫עקוב בעזרת טבלת מעקב אחר ביצוע הפעולה ‪ Sod‬בעבור המערך הנתון ‪a‬‬
‫והמספר ‪ . k = 10‬רשום את הערך המוחזר‪.‬‬
‫בטבלת המעקב יש לכלול את העמודות שפורטו בסעיף א‪.‬‬
‫ג‪.‬‬
‫מהי טענת היציאה של הפעולה ‪? Sod‬‬
‫ד‪.‬‬
‫מהי סיבוכיות זמן הריצה של הפעולה ‪ ? Sod‬נמק את תשובתך‪.‬‬
‫ה‪.‬‬
‫עקוב בעזרת טבלת מעקב אחר ביצוע הפעולה ‪ What‬בעבור המערך הנתון ‪a‬‬
‫והמספר ‪ . k = 11‬רשום את הערך המוחזר‪.‬‬
‫בטבלת המעקב יש לכלול עמודות בעבור‪, left, right, a[left], a[right] :‬‬
‫‬
‫ושתי עמודות נוספות לכל אחת מפקודות ‪ . if‬בכל עמודה יצוין אם התנאי‬
‫‬
‫בפקודת ‪ if‬מתקיים או אינו מתקיים‪.‬‬
‫ו‪.‬‬
‫מהי סיבוכיות זמן הריצה של הפעולה ‪ ? What‬נמק את תשובתך‪.‬‬
‫ז‪.‬‬
‫מי מבין שתי הפעולות — ‪ Sod‬או ‪ — What‬יעילה יותר? נמק את תשובתך‪.‬‬
‫ח‪.‬‬
‫טענת הכניסה של הפעולות ‪ Sod‬ו– ‪ What‬שונתה כך שאפשר להעביר אליהן‬
‫מערך ‪ a‬לא ממוין‪.‬‬
‫‬
‫(‪ )1‬האם טענת היציאה של הפעולה ‪ Sod‬תשתנה? נמק את תשובתך‪.‬‬
‫‬
‫(‪ )2‬האם טענת היציאה של הפעולה ‪ What‬תשתנה? נמק את תשובתך‪.‬‬
‫‪/‬המשך בעמוד ‪/10‬‬
‫‬
‫ ‪- 10‬‬‫‪.3‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫שים לב‪ :‬לשאלה זו שני נוסחים‪ :‬אחד ב– ‪( Java‬עמודים ‪ , )11-10‬ואחד ב– ‪C#‬‬
‫(עמודים ‪ .)13-12‬עבוד על פי השפה שלמדת‪.‬‬
‫‬
‫לפותרים ב– ‪Java‬‬
‫‬
‫לפניך ממשק של המחלקה "תור–ביטול" )‪: (UndoQueue‬‬
‫‬
‫המחלקה מגדירה טיפוס אוסף עם פרוטוקול ‪ FIFO‬להכנסה והוצאה של ערכים שלמים‬
‫וגדולים מ– ‪.0‬‬
‫תיאור‬
‫הפעולה בונה תור–ביטול ריק‪.‬‬
‫הפעולה מחזירה ‪ true‬אם התור–ביטול הנוכחי‬
‫ריק‪ ,‬אחרת — הפעולה מחזירה ‪.false‬‬
‫הפעולה מכניסה את הערך ‪ x‬לסוף התור–ביטול‬
‫הנוכחי‪.‬‬
‫הפעולה מוציאה את הערך שבראש התור–ביטול‬
‫הנוכחי‪ ,‬ומחזירה אותו‪.‬‬
‫הנחה‪ :‬התור–ביטול הנוכחי אינו ריק‪.‬‬
‫הפעולה מחזירה את הערך של האיבר שבראש‬
‫התור–ביטול בלי להוציאו‪.‬‬
‫הנחה‪ :‬התור–ביטול הנוכחי אינו ריק‪.‬‬
‫הפעולה מבטלת את פעולת ה– ‪ remove‬או את‬
‫פעולת ה– ‪ insert‬האחרונה שבוצעה‪ ,‬ומשחזרת‬
‫את התור–ביטול כפי שהיה לפני ביצוע הפעולה‪.‬‬
‫אם אין פעולות ‪ remove‬או ‪ insert‬שבוצעו‪,‬‬
‫הפעולה אינה עושה דבר‪.‬‬
‫שים–לב‪ :‬הפעלה ‪ n‬פעמים של הפעולה ‪,undo‬‬
‫תחזיר את התור–ביטול למצב שבו הוא היה‬
‫לפני ביצוע ‪ n‬פעולות ‪ remove‬או ‪insert‬‬
‫האחרונות שטרם בוטלו‪.‬‬
‫שם הפעולה‬
‫)(‪UndoQueue‬‬
‫)(‪boolean isEmpty‬‬
‫)‪void insert(int x‬‬
‫)(‪int remove‬‬
‫)(‪int head‬‬
‫)(‪void undo‬‬
‫‬
‫‬
‫‪/‬המשך בעמוד ‪/11‬‬
‫ ‪- 11‬‬‫דוגמה‪:‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫‬
‫מצב התור–ביטול‬
‫הפעולה‬
‫לאחר ביצוע הפעולה‬
‫;)(‪ UndoQueue uq = new UndoQueue‬התור–ביטול ריק‬
‫;)‪uq.insert(2‬‬
‫;)‪uq.insert(3‬‬
‫;)(‪uq.remove‬‬
‫;)‪uq.insert(4‬‬
‫;)(‪uq.remove‬‬
‫;)(‪ uq.remove‬התור–ביטול ריק‬
‫;)(‪"4" uq.undo‬‬
‫;)(‪"4 , 3" uq.undo‬‬
‫;)‪"1 , 4 , 3" uq.insert(1‬‬
‫;)(‪"4 , 3" uq.undo‬‬
‫;)(‪"3" uq.undo‬‬
‫;)(‪"3 , 2" uq.undo‬‬
‫;)(‪"2" uq.undo‬‬
‫;)(‪ uq.undo‬התור–ביטול ריק‬
‫"‪"2‬‬
‫"‪"3 , 2‬‬
‫"‪"3‬‬
‫"‪"4 , 3‬‬
‫"‪"4‬‬
‫;)(‪ uq.undo‬התור–ביטול ריק‬
‫א‪.‬‬
‫‬
‫ב‪.‬‬
‫ג‪.‬‬
‫‬
‫‬
‫לפניך קטע קוד‪.‬‬
‫;)(‪UndoQueue q = new UndoQueue‬‬
‫;)‪q.insert(1‬‬
‫;)‪q.insert(2‬‬
‫;)‪q.insert(3‬‬
‫;)(‪q.remove‬‬
‫;)‪q.insert(4‬‬
‫;)(‪q.undo‬‬
‫;)(‪q.undo‬‬
‫הראה את מצב התור–ביטול לאחר הביצוע של כל הוראה בקטע הקוד‪.‬‬
‫כתוב ב– ‪ Java‬את כותרת המחלקה ‪ , UndoQueue‬ואת התכונות שלה‪ .‬רשום תיעוד‬
‫לכל תכונה‪.‬‬
‫ממש ב– ‪ Java‬את הפעולות ‪ remove , insert‬ו– ‪ undo‬המוצגות בממשק המחלקה‬
‫‪.UndoQueue‬‬
‫אתה יכול להשתמש בפעולות הממשק האחרות של ‪ UndoQueue‬בלי לממש אותן‪.‬‬
‫אם אתה משתמש בפעולות נוספות‪ ,‬עליך לממש אותן‪.‬‬
‫‪/‬המשך בעמוד ‪/12‬‬
‫‪- 12 -‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫לפותרים ב– ‪C#‬‬
‫‬
‫לפניך ממשק של המחלקה "תור–ביטול" )‪: (UndoQueue‬‬
‫‬
‫המחלקה מגדירה טיפוס אוסף עם פרוטוקול ‪ FIFO‬להכנסה והוצאה של ערכים שלמים‬
‫וגדולים מ– ‪.0‬‬
‫תיאור‬
‫הפעולה בונה תור–ביטול ריק‪.‬‬
‫הפעולה מחזירה ‪ true‬אם התור–ביטול הנוכחי‬
‫ריק‪ ,‬אחרת — הפעולה מחזירה ‪.false‬‬
‫הפעולה מכניסה את הערך ‪ x‬לסוף התור–ביטול‬
‫הנוכחי‪.‬‬
‫הפעולה מוציאה את הערך שבראש התור–ביטול‬
‫הנוכחי‪ ,‬ומחזירה אותו‪.‬‬
‫הנחה‪ :‬התור–ביטול הנוכחי אינו ריק‪.‬‬
‫הפעולה מחזירה את הערך של האיבר שבראש‬
‫התור–ביטול בלי להוציאו‪.‬‬
‫הנחה‪ :‬התור–ביטול הנוכחי אינו ריק‪.‬‬
‫הפעולה מבטלת את פעולת ה– ‪ Remove‬או את‬
‫פעולת ה– ‪ Insert‬האחרונה שבוצעה‪ ,‬ומשחזרת‬
‫את התור–ביטול כפי שהיה לפני ביצוע הפעולה‪.‬‬
‫אם אין פעולות ‪ Remove‬או ‪ Insert‬שבוצעו‪,‬‬
‫הפעולה אינה עושה דבר‪.‬‬
‫שים–לב‪ :‬הפעלה ‪ n‬פעמים של הפעולה ‪,Undo‬‬
‫תחזיר את התור–ביטול למצב שבו הוא היה‬
‫לפני ביצוע ‪ n‬פעולות ‪ Remove‬או ‪Insert‬‬
‫האחרונות שטרם בוטלו‪.‬‬
‫שם הפעולה‬
‫)(‪UndoQueue‬‬
‫)(‪bool IsEmpty‬‬
‫)‪void Insert(int x‬‬
‫)(‪int Remove‬‬
‫)(‪int Head‬‬
‫)(‪void Undo‬‬
‫‬
‫‪/‬המשך בעמוד ‪/13‬‬
‫ ‪- 13‬‬‫דוגמה‪:‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫‬
‫מצב התור–ביטול‬
‫הפעולה‬
‫לאחר ביצוע הפעולה‬
‫;)(‪ UndoQueue uq = new UndoQueue‬התור–ביטול ריק‬
‫;)‪uq.Insert(2‬‬
‫;)‪uq.Insert(3‬‬
‫;)(‪uq.Remove‬‬
‫;)‪uq.Insert(4‬‬
‫;)(‪uq.Remove‬‬
‫;)(‪ uq.Remove‬התור–ביטול ריק‬
‫;)(‪"4" uq.Undo‬‬
‫;)(‪"4 , 3" uq.Undo‬‬
‫;)‪"1 , 4 , 3" uq.Insert(1‬‬
‫;)(‪"4 , 3" uq.Undo‬‬
‫;)(‪"3" uq.Undo‬‬
‫;)(‪"3 , 2" uq.Undo‬‬
‫;)(‪"2" uq.Undo‬‬
‫;)(‪ uq.Undo‬התור–ביטול ריק‬
‫"‪"2‬‬
‫"‪"3 , 2‬‬
‫"‪"3‬‬
‫"‪"4 , 3‬‬
‫"‪"4‬‬
‫;)(‪ uq.Undo‬התור–ביטול ריק‬
‫א‪.‬‬
‫‬
‫ב‪.‬‬
‫ג‪.‬‬
‫‬
‫‬
‫לפניך קטע קוד‪.‬‬
‫;)(‪UndoQueue q = new UndoQueue‬‬
‫;)‪q.Insert(1‬‬
‫;)‪q.Insert(2‬‬
‫;)‪q.Insert(3‬‬
‫;)(‪q.Remove‬‬
‫;)‪q.Insert(4‬‬
‫;)(‪q.Undo‬‬
‫;)(‪q.Undo‬‬
‫הראה את מצב התור–ביטול לאחר הביצוע של כל הוראה בקטע הקוד‪.‬‬
‫כתוב ב– ‪ C#‬את כותרת המחלקה ‪ , UndoQueue‬ואת התכונות שלה‪ .‬רשום תיעוד‬
‫לכל תכונה‪.‬‬
‫ממש ב– ‪ C#‬את הפעולות ‪ Remove , Insert‬ו– ‪ Undo‬המוצגות בממשק המחלקה‬
‫‪.UndoQueue‬‬
‫אתה יכול להשתמש בפעולות הממשק האחרות של ‪ UndoQueue‬בלי לממש אותן‪.‬‬
‫אם אתה משתמש בפעולות נוספות‪ ,‬עליך לממש אותן‪.‬‬
‫‪/‬המשך בעמוד ‪/14‬‬
‫ ‪- 14‬‬‫א‪.‬‬
‫‪.4‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫לפניך כותרת של פעולה‪:‬‬
‫‬
‫ב– ‪: Java‬‬
‫‬
‫ב– ‪: C#‬‬
‫‬
‫הפעולה מקבלת עץ בינרי לא ריק ‪ t‬של מספרים שלמים‪ ,‬ומחסנית ריקה ‪s‬‬
‫)‪public static void leaves(BinTreeNode<Integer> t , Stack<Integer> s‬‬
‫)‪public static void Leaves(BinTreeNode<int> t , Stack<int> s‬‬
‫‬
‫של מספריםשלמים‪.‬‬
‫‬
‫הפעולה מכניסה למחסנית את ערכי כל העלים של העץ ‪ , t‬על פי סדר סריקה‬
‫‬
‫מימין לשמאל‪.‬‬
‫‬
‫ממש ב– ‪ Java‬או ב– ‪ C#‬את הפעולה‪.‬‬
‫ב‪.‬‬
‫כתוב ב– ‪ Java‬או ב– ‪ C#‬פעולה בוליאנית שתקבל ‪ 2‬עצים בינריים לא ריקים‬
‫‬
‫של מספרים שלמים‪ ,‬ותחזיר ‪ true‬אם מתקיימים שני התנאים האלה‪:‬‬
‫‬
‫‬
‫—‬
‫יש להם אותו מספר עלים‬
‫‬
‫—‬
‫על פי סדר הסריקה מימין לשמאל‪ ,‬ערכי העלים שווים‬
‫‬
‫אחרת — הפעולה תחזיר ‪. false‬‬
‫‬
‫עליך להשתמש בפעולה שמִמשת בסעיף א‪.‬‬
‫‪/‬המשך בעמוד ‪/15‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫‪- 15 -‬‬
‫פרק שני‬
‫(‪ 50‬נקודות)‬
‫בפרק זה שאלות בארבעה מסלולים‪:‬‬
‫מערכות מחשב ואסמבלר‪ ,‬עמ' ‪20-15‬‬
‫‬
‫מבוא לחקר ביצועים‪ ,‬עמ' ‪31-21‬‬
‫‬
‫מודלים חישוביים‪ ,‬עמ' ‪34-32‬‬
‫‬
‫תכנות מונחה עצמים ב– ‪ , Java‬עמ' ‪ ; 45-36‬תכנות מונחה עצמים ב– ‪ , C#‬עמ' ‪55-46‬‬
‫‬
‫ענה רק על שאלות במסלול שלמדת‪.‬‬
‫מערכות מחשב ואסמבלר‬
‫אם למדת מסלול זה‪ ,‬ענה על שתיים מהשאלות ‪( 8-5‬לכל שאלה — ‪ 25‬נקודות)‪.‬‬
‫‪.5‬‬
‫במחסנית מאוחסנים ‪ 10‬מספרים שלמים עם סימן‪ ,‬בגודל מילה‪.‬‬
‫‬
‫בנוסף‪ ,‬במקטע הנתונים מוגדרים משתנה ‪ K‬ושני מערכים‪ ARR1 ,‬ו– ‪. ARR2‬‬
‫‬
‫כל תאי המערך ‪ ARR1‬מאותחלים ל– ‪ , 0‬והמשתנה ‪ K‬מאותחל ל– ‪. 0‬‬
‫)‪DUP (0‬‬
‫)?( ‪DUP‬‬
‫‪10‬‬
‫‪10‬‬
‫‪0‬‬
‫‪DW‬‬
‫‪DW‬‬
‫‪DW‬‬
‫‪ARR1‬‬
‫‪ARR2‬‬
‫‪K‬‬
‫‬
‫יש להעתיק למערך ‪ ARR1‬את כל המספרים שמאוחסנים במחסנית באופן הזה‪:‬‬
‫‬
‫כל המספרים השליליים יאוחסנו בתחילת המערך לפי סדר הוצאתם מהמחסנית‪ .‬אחרי‬
‫‬
‫המספרים השליליים יאוחסנו כל האפסים‪ ,‬ולאחר מכן יאוחסנו כל המספרים החיוביים‬
‫לפי סדר הוצאתם מהמחסנית‪.‬‬
‫‬
‫לדוגמה‪ ,‬בעבור המחסנית שלפניך המכילה ‪ 6‬איברים‪:‬‬
‫‬
‫‪-5‬‬
‫‪0‬‬
‫‪10‬‬
‫‪-2‬‬
‫‪0‬‬
‫‪8‬‬
‫ייראה המערך ‪ ARR1‬כך‪:‬‬
‫‪5‬‬
‫‪8‬‬
‫‪4‬‬
‫‪10‬‬
‫‪3‬‬
‫‪0‬‬
‫‪2‬‬
‫‪0‬‬
‫‪1‬‬
‫‪-2‬‬
‫‪0‬‬
‫‪-5‬‬
‫‪/‬המשך בעמוד ‪/16‬‬
‫‬
‫‪- 16 -‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫לפניך קטע תכנית באסמבלר‪ ,‬המבצע את הנדרש‪.‬‬
‫מקטע התכנית הושמטו שורות במקומות המסומנים במספרים ‪. iv-i‬‬
‫רשום במחברתך את מספרי השורות המסומנות‪ ,‬וכתוב ליד כל אחד מהמספרים את‬
‫שורת הפקודה החסרה‪ ,‬כדי שקטע התכנית יבצע את הנדרש‪.‬‬
‫‪SI , 0‬‬
‫‪DI , 0‬‬
‫‪CX , 10‬‬
‫‪AX‬‬
‫‪A2‬‬
‫‪DI , 2‬‬
‫‪A4‬‬
‫‪AX , 0‬‬
‫‪A3‬‬
‫‪K‬‬
‫‪A4‬‬
‫‪SI , 2‬‬
‫‪A1‬‬
‫‪SI , K‬‬
‫‪SI , K‬‬
‫‪CX , DI‬‬
‫‪CX , 1‬‬
‫‪BX , BX‬‬
‫]‪DX , ARR2[BX‬‬
‫‪ARR1[SI] , DX‬‬
‫‪BX , 2‬‬
‫‪A5‬‬
‫ ‪MOV‬‬
‫‪MOV‬‬
‫‪MOV‬‬
‫ ‪POP‬‬
‫‬
‫‪JLE‬‬
‫‬
‫ ‪ADD‬‬
‫ ‪JMP‬‬
‫‪CMP‬‬
‫‪JNE‬‬
‫‪INC‬‬
‫‪JMP‬‬
‫‬
‫ ‪ADD‬‬
‫‪LOOP‬‬
‫‪ADD‬‬
‫‪ADD‬‬
‫‪MOV‬‬
‫‪SHR‬‬
‫‪XOR‬‬
‫‪MOV‬‬
‫‪MOV‬‬
‫‬
‫‪ADD‬‬
‫‪LOOP‬‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫‪A1:‬‬
‫ ‪i‬‬
‫‬
‫ ‪ii‬‬
‫‬
‫‬
‫‬
‫‪A2:‬‬
‫‬
‫‬
‫‬
‫‪iii A3:‬‬
‫‬
‫‪ A4:‬‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫‪ A5:‬‬
‫‬
‫ ‪iv‬‬
‫‬
‫‬
‫‪/‬המשך בעמוד ‪/17‬‬
‫ ‪- 17‬‬‫‪.6‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫מערך ‪ A‬נקרא מוכל במערך ‪ , B‬אם האורך של מערך ‪ A‬אינו עולה על האורך של מערך ‪,B‬‬
‫וכל הערכים של איברי מערך ‪ A‬נמצאים במערך ‪ B‬ברצף ובאותו סדר כמו במערך ‪. A‬‬
‫‬
‫בכל מערך מאוחסנים מספרים שלמים עם סימן‪ ,‬השונים זה מזה‪.‬‬
‫‬
‫לדוגמה‪:‬‬
‫‬
‫בעבור המערכים ‪ A‬ו– ‪ B‬שלפניך‪ ,‬המערך ‪ A‬מוכל במערך ‪. B‬‬
‫‬
‫מערך ‪:A‬‬
‫‬
‫מערך ‪:B‬‬
‫‬
‫איברי המערך ‪ B‬המסומנים באפור הם הערכים של איברי המערך ‪. A‬‬
‫‬
‫א‪.‬‬
‫‬
‫‪5‬‬
‫‪11‬‬
‫‪9‬‬
‫‪2‬‬
‫‪8‬‬
‫‪11‬‬
‫‪7‬‬
‫‪5‬‬
‫‪6‬‬
‫‪8‬‬
‫‪5‬‬
‫‪0‬‬
‫‪3‬‬
‫‪8‬‬
‫‪4‬‬
‫‪5‬‬
‫‪4‬‬
‫‪-5‬‬
‫‪3‬‬
‫‪3‬‬
‫‪2‬‬
‫‪0‬‬
‫‪1‬‬
‫‪-5‬‬
‫‪2‬‬
‫‪4‬‬
‫‪1‬‬
‫‪-7‬‬
‫‪0‬‬
‫‪15‬‬
‫במקטע הנתונים הוגדרו הנתונים כך‪:‬‬
‫)?( ‪DUP‬‬
‫‪ARR_B DB 100‬‬
‫‬
‫)?( ‪DUP‬‬
‫‪ARR_A DB 10‬‬
‫‬
‫‬
‫? ‪ DB‬‬
‫‪V‬‬
‫‬
‫‬
‫? ‪ DB‬‬
‫‪P‬‬
‫‬
‫‬
‫‬
‫‬
‫כתוב באסמבלר שגרה (פרוצדורה) בשם ‪ , TEST‬שתקבל ערך שמאוחסן במשתנה ‪. V‬‬
‫‬
‫‬
‫השגרה תבדוק אם הערך שמאוחסן במשתנה ‪ V‬נמצא במערך ‪. ARR_B‬‬
‫‬
‫אם כן — השגרה תאחסן במשתנה ‪ P‬את האינדקס של האיבר המתאים‪,‬‬
‫‬
‫‪0‬‬
‫‪3‬‬
‫‬
‫אחרת — השגרה תאחסן במשתנה ‪ P‬את הערך ‪. -1‬‬
‫ב‪.‬‬
‫כתוב באסמבלר קטע תכנית שיבדוק אם המערך ‪ ARR_A‬מוכל במערך ‪. ARR_B‬‬
‫‬
‫אם כן — קטע התכנית יאחסן ‪ 1‬באוגר ‪ , BL‬אחרת — הוא יאחסן ‪ 0‬באוגר ‪. BL‬‬
‫‬
‫עליך להשתמש בשגרה ‪ TEST‬שכתבת בסעיף א‪.‬‬
‫‬
‫הנח שהאורך של המערך ‪ ARR_A‬אינו עולה על האורך של מערך ‪. ARR_B‬‬
‫‪/‬המשך בעמוד‪/18‬‬
‫ ‪- 18‬‬‫‪.7‬‬
‫‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫בשאלה זו שני סעיפים א‪-‬ב‪ ,‬שאין קשר ביניהם‪ .‬ענה על שניהם‪.‬‬
‫א‪ .‬במקטע הנתונים הוגדר מערך ‪: ARR‬‬
‫‬
‫)?( ‪DUP‬‬
‫‪DB 6‬‬
‫‪ARR‬‬
‫‬
‫‬
‫יש להפוך את סדר האיברים במערך‪.‬‬
‫לדוגמה‪ ,‬נתון המערך‪:‬‬
‫‬
‫לאחר הפיכת סדר האיברים‪ ,‬ייראה המערך כך‪:‬‬
‫‬
‫‬
‫‬
‫‬
‫לפניך ‪ 2‬קטעים באסמבלר‪ , ii-i ,‬שמטרתם להפוך את סדר האיברים‬
‫במערך ‪. ARR‬‬
‫עקוב בעזרת טבלת מעקב אחר הביצוע של כל אחד מהקטעים ‪ ii-i‬שלפניך‪ ,‬וקבע אם‬
‫הוא מבצע את הנדרש או אינו מבצע את הנדרש‪.‬‬
‫‪5‬‬
‫‪7‬‬
‫‪5‬‬
‫‪3‬‬
‫‪4‬‬
‫‪6‬‬
‫‪4‬‬
‫‪2‬‬
‫‪3‬‬
‫‪0‬‬
‫‪3‬‬
‫‪10‬‬
‫‪2‬‬
‫‪10‬‬
‫‪2‬‬
‫‪0‬‬
‫‪1‬‬
‫‪2‬‬
‫‪1‬‬
‫‪6‬‬
‫‪0‬‬
‫‪3‬‬
‫‪0‬‬
‫‪7‬‬
‫‪MOV SI , 3‬‬
‫‪MOV DI , 2‬‬
‫]‪MOV AL , ARR[DI‬‬
‫]‪MOV AH , ARR[SI‬‬
‫‪ADD ARR[DI] , AH‬‬
‫‪SUB ARR[DI] , AL‬‬
‫‪MOV ARR[SI] , AL‬‬
‫‪INC SI‬‬
‫‪DEC DI‬‬
‫‪JNZ A1‬‬
‫ ‪i‬‬
‫‬
‫‬
‫‪A1:‬‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫‪MOV CX , 3‬‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫‪MOV SI , 3‬‬
‫‪MOV DI , 2‬‬
‫]‪MOV AL , ARR[DI‬‬
‫]‪MOV AH , ARR[SI‬‬
‫‪MOV ARR[DI] , AH‬‬
‫‪MOV ARR[SI] , AL‬‬
‫‪INC SI‬‬
‫‪DEC DI‬‬
‫‪LOOPA1‬‬
‫ ‪ii‬‬
‫‬
‫‬
‫‬
‫‬
‫‪A1:‬‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫‪/‬המשך בעמוד ‪/19‬‬
‫ ‪- 19‬‬‫ב‪.‬‬
‫‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫(אין קשר לסעיף א‪).‬‬
‫‬
‫במקטע הנתונים הוגדרו הנתונים כך‪:‬‬
‫‬
‫שים לב‪ :‬המספרים הם עשרוניים‪.‬‬
‫‬
‫לפניך קטע תכנית באסמבלר‪ ,‬שמטרתו לחשב את סכום האיברים במערך ‪. T‬‬
‫‪55 , 90 , 110 , 1‬‬
‫‪CX , 4‬‬
‫‪AX , AX‬‬
‫‪BX , T‬‬
‫]‪AL , [BX‬‬
‫‪BX‬‬
‫‪AGAIN‬‬
‫‪MOV‬‬
‫‪XOR‬‬
‫‪LEA‬‬
‫‪ADD‬‬
‫‪INC‬‬
‫‪LOOP‬‬
‫‪DB‬‬
‫‪T‬‬
‫‬
‫‬
‫‬
‫‬
‫‪AGAIN:‬‬
‫‬
‫‬
‫‬
‫קטע התכנית אינו מבצע את הנדרש‪.‬‬
‫‬
‫(‪ )1‬עקוב בעזרת טבלת מעקב אחר ביצוע קטע התכנית‪ ,‬וכתוב מה יהיה התוכן‬
‫‬
‫של ‪ ,AL‬ומה יהיה התוכן של דגל הנשא ושל דגל הגלישה בסיום הביצוע של‬
‫‬
‫קטע התכנית‪.‬‬
‫‬
‫‬
‫‬
‫(‪ )2‬שנה את קטע התכנית כך שיחשב את סכום האיברים במערך הנתון ‪.T‬‬
‫העתק למחברתך את קטע התכנית לאחר השינוי‪.‬‬
‫‬
‫‬
‫‪/‬המשך בעמוד ‪/20‬‬
‫ ‪- 20‬‬‫‪.8‬‬
‫לפניך קטע תכנית באסמבלר‪:‬‬
‫‬
‫נתון שלפני ביצוע קטע התכנית‪:‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫‪BP‬‬
‫‪BP , SP‬‬
‫]‪AX , [BP+4‬‬
‫]‪BP , [BP‬‬
‫‪SP , 4‬‬
‫‪PUSHF‬‬
‫‪PUSH‬‬
‫‪MOV‬‬
‫‪MOV‬‬
‫‪MOV‬‬
‫‪ADD‬‬
‫‪POPF‬‬
‫‪i‬‬
‫‪ii‬‬
‫‪iii‬‬
‫‪iv‬‬
‫‪v‬‬
‫‪vi‬‬
‫‪vii‬‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫—‬
‫התוכן של אוגר הדגלים הוא ‪3202H‬‬
‫‬
‫—‬
‫התוכן של האוגר ‪ SP‬הוא ‪96H‬‬
‫‬
‫—‬
‫התוכן של האוגר ‪ BP‬הוא ‪5678H‬‬
‫‬
‫‬
‫‬
‫לפניך חלק ממחסנית המכילה מספרים הקסדצימליים‪.‬‬
‫לפני ביצוע קטע התכנית‪ ,‬האוגר ‪ SP‬מצביע על התא המסומן בחץ‪ ,‬שכתובתו היחסית ‪. 96H‬‬
‫‪......‬‬
‫*‬
‫*‬
‫*‬
‫*‬
‫*‬
‫* ‪* 02H 32H‬‬
‫*‬
‫סטֵי התאים‬
‫‪ֶ 90H 91H 92H 93H 94H 95H 96H 97H 98H 99H‬ה ֵ‬
‫‬
‫תא המסומן ב– * הוא תא שאין משמעות לתוכנו‪.‬‬
‫‬
‫א‪.‬‬
‫עקוב בעזרת טבלת מעקב אחר ביצוע קטע התכנית‪.‬‬
‫בטבלת המעקב יש לכלול עמודות בעבור האוגרים‪. AX , BP , SP :‬‬
‫‬
‫ב‪.‬‬
‫על פי טבלת המעקב‪ ,‬ענה על התת–סעיפים (‪.)4(-)1‬‬
‫‬
‫(‪ )1‬איזה מספר יירשם במחסנית הנתונה לאחר ביצוע הוראה ‪? i‬‬
‫‬
‫כתוב את הכתובת היחסית של התאים שבהם יירשם המספר‪.‬‬
‫‬
‫(‪ )2‬מה יהיה התוכן של האוגר ‪ BP‬לאחר ביצוע הוראה ‪? iii‬‬
‫‬
‫(‪ )3‬מה יהיה התוכן של האוגר ‪ AX‬לאחר ביצוע הוראה ‪? iv‬‬
‫‬
‫(‪ )4‬מה יהיה התוכן של האוגר ‪ BP‬לאחר ביצוע הוראה ‪? v‬‬
‫‪/‬המשך בעמוד ‪/21‬‬
‫‪- 21 -‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫מבוא לחקר ביצועים‬
‫אם למדת מסלול זה‪ ,‬ענה על שתיים מהשאלות ‪( 12-9‬לכל שאלה — ‪ 25‬נקודות)‪.‬‬
‫‪.9‬‬
‫בשאלה זו שלושה סעיפים א‪-‬ג‪ ,‬שאינם תלויים זה בזה‪ .‬ענה על כל הסעיפים‪.‬‬
‫יהי )‪ G = (V , E‬גרף מכוון‪ V ,‬היא קבוצת הקדקודים ו–‪ E‬היא קבוצת הקשתות‪ .‬‬
‫א‪.‬‬
‫‬
‫‪ G‬מיוצג על ידי מטריצת הסמיכויות שלפניך‪:‬‬
‫‬
‫‪t‬‬
‫‪u‬‬
‫‪u‬‬
‫‪u‬‬
‫‪u‬‬
‫‪u‬‬
‫‪u‬‬
‫‪u‬‬
‫‪v‬‬
‫‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪d‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫(‪ )1‬סרטט את הגרף ‪ G‬המיוצג על ידי המטריצה‪.‬‬
‫‬
‫‪a‬‬
‫‪b‬‬
‫‪c‬‬
‫‪d‬‬
‫‪e‬‬
‫(‪ )2‬מצא את רכיב ‪ /‬רכיבי הקשירות החזקה (רק"ח ‪ /‬רק"חים) שבגרף ‪. G‬‬
‫‬
‫‬
‫בעבור כל רק"ח שמצאת‪ ,‬רשום את קבוצת הקדקודים שלו‪.‬‬
‫(‪ )3‬הסר קשת אחת מהגרף ‪ G‬שסרטטת‪ ,‬כך שמספר הרק"חים יגדל ב– ‪.1‬‬
‫‬
‫‬
‫ב‪.‬‬
‫‬
‫‪e‬‬
‫‪c‬‬
‫‪b‬‬
‫‪a‬‬
‫‪p‬‬
‫‪q0‬‬
‫‪q0‬‬
‫‪q‬‬
‫‪q0‬‬
‫‪q‬‬
‫‪q0‬‬
‫‪q1‬‬
‫‪r‬‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫ציין את הקשת שהסרת‪ ,‬ולכל רק"ח רשום את קבוצת הקדקודים שלו‪.‬‬
‫יהי )‪ G = (V , E‬גרף מכוון‪ V ,‬היא קבוצת הקדקודים ו–‪ E‬היא קבוצת הקשתות‪ .‬‬
‫‪ G‬מיוצג על ידי רשימת הסמיכויות הזו‪:‬‬
‫‬
‫‪g‬‬
‫‪c‬‬
‫‪b‬‬
‫‪a‬‬
‫‪c‬‬
‫‪e‬‬
‫‪d‬‬
‫‪b‬‬
‫‪f‬‬
‫‪c‬‬
‫‪f‬‬
‫‪d‬‬
‫‪d‬‬
‫‪c‬‬
‫‪a‬‬
‫‪e‬‬
‫‪a‬‬
‫‪c‬‬
‫‪f‬‬
‫‪f‬‬
‫‪b‬‬
‫‪g‬‬
‫(‪ )1‬הפעל אלגוריתם סריקה לעומק )‪ (DFS‬על הגרף הנתון החל מקדקוד ‪. a‬‬
‫‬
‫סרטט במחברתך את העץ הפורש ‪ DFS‬שמתקבל‪.‬‬
‫(‪ )2‬הפעל אלגוריתם סריקה לרוחב )‪ (BFS‬על הגרף הנתון החל מקדקוד ‪. d‬‬
‫סרטט במחברתך את העץ הפורש ‪ BFS‬שמתקבל‪.‬‬
‫‪/‬המשך בעמוד ‪/22‬‬
‫‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫‪- 22 -‬‬
‫ג‪ .‬יהי ‪ G‬גרף מכוון‪.‬‬
‫‬
‫‬
‫נפעיל את האלגוריתם סריקה לעומק )‪ (DFS‬על הגרף המכוון ‪. G‬‬
‫‬
‫נגדיר את הקשתות של הגרף ‪ G‬בעזרת העץ הפורש ‪ /‬היער הפורש שנוצר‪.‬‬
‫‬
‫קשת עץ היא קשת של הגרף ‪ , G‬הנמצאת גם בעץ הפורש ‪ /‬היער הפורש של ‪. G‬‬
‫‬
‫קשת אחורית היא קשת )‪ (u , v‬בגרף ‪ , G‬שאינה נמצאת בעץ הפורש ‪ /‬ביער הפורש‪ .‬‬
‫זו קשת מקדקוד ‪ u‬לקדקוד ‪ v‬בגרף ‪ , G‬כאשר ‪ v‬הוא אב קדמון של ‪u‬‬
‫‬
‫בעץ הפורש ‪ /‬ביער הפורש‪.‬‬
‫‬
‫קשת קדמית היא קשת )‪ (u , v‬בגרף ‪ , G‬שאינה נמצאת בעץ הפורש ‪ /‬ביער הפורש ‪.‬‬
‫‬
‫זו קשת מקדקוד ‪ u‬לקדקוד ‪ v‬בגרף ‪ , G‬כאשר ‪ v‬הוא צאצא של ‪u‬‬
‫‬
‫בעץ הפורש ‪ /‬ביער הפורש‪.‬‬
‫‬
‫קשת חוצה היא קשת )‪ (u , v‬בגרף ‪ , G‬שאינה נמצאת בעץ הפורש ‪ /‬ביער הפורש‪,‬‬
‫‬
‫‬
‫ואינה קשת אחורית או קשת קדמית‪ .‬זו קשת מקודקוד ‪ u‬לקדקוד ‪ v‬בגרף ‪, G‬‬
‫בתנאי שאף אחד משני קדקודים אלה אינו צאצא של הקדקוד האחר‬
‫‬
‫בעץ הפורש ‪ /‬ביער הפורש‪.‬‬
‫‬
‫‬
‫(‪ )1‬לפניך גרף מכוון ‪ , G‬המכיל יותר מרק"ח (רכיב קשירות חזקה) אחד‪.‬‬
‫‬
‫‪a‬‬
‫‪b‬‬
‫‪e‬‬
‫‪f‬‬
‫‬
‫‬
‫לאחר הפעלת אלגוריתם הסריקה לעומק )‪ (DFS‬על הגרף המכוון ‪ G‬הנתון‪,‬‬
‫התקבל היער הפורש שלפניך‪:‬‬
‫‬
‫‬
‫‪f‬‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫‪g‬‬
‫‪d‬‬
‫‪c‬‬
‫‪e‬‬
‫‪b‬‬
‫‪a‬‬
‫‪g‬‬
‫‪d‬‬
‫‪c‬‬
‫העתק למחברתך את הגרף ‪ .G‬הסתמך על היער הפורש הנתון וכתוב ליד‬
‫כל אחת מהקשתות של הגרף ‪ G‬אם היא‪:‬‬
‫— קשת עץ‬
‫— קשת אחורית‬
‫— קשת קדמית‬
‫— קשת חוצה‬
‫‪/‬המשך בעמוד ‪/23‬‬
‫‬
‫ ‪- 23‬‬‫‬
‫‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫(‪ )2‬לפניך טענה שחסר בה ביטוי במקום המסומן בקו‪.‬‬
‫אם לאחר הפעלת האלגוריתם סריקה לעומק (‪ )DFS‬על גרף מכוון ‪G‬‬
‫‪ ,‬אזי יש ב– ‪ G‬מעגל ‪ /‬מעגלים‪.‬‬
‫‬
‫נמצאת ב– ‪G‬‬
‫‬
‫לפניך ארבעה ביטויים אפשריים להשלמת הטענה‪:‬‬
‫‬
‫— קשת עץ‬
‫‬
‫— קשת אחורית‬
‫‬
‫— קשת קדמית‬
‫‬
‫— קשת חוצה‬
‫‬
‫העתק למחברתך את האפשרות המתאימה להשלמת הטענה‪ ,‬ונמק את קביעתך‪.‬‬
‫‬
‫‪/‬המשך בעמוד ‪/24‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫‪- 24 -‬‬
‫‪ .10‬בשאלה זו שני סעיפים א‪-‬ב שאינם תלויים זה בזה‪ .‬ענה על שני הסעיפים‪.‬‬
‫א‪.‬‬
‫לפניך רשת )‪ V , G = (V , E‬היא קבוצת הקדקודים ו– ‪ E‬היא קבוצת הקשתות‪:‬‬
‫‬
‫ ‬
‫‪6‬‬
‫‪4‬‬
‫‪F‬‬
‫‪H‬‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫‪E‬‬
‫‪4‬‬
‫‪4‬‬
‫‪G‬‬
‫‪20‬‬
‫‪B‬‬
‫‪8‬‬
‫‪C‬‬
‫‪16‬‬
‫‪D‬‬
‫‪4‬‬
‫‪2‬‬
‫‬
‫‪3‬‬
‫‪A‬‬
‫‪2‬‬
‫השתמש באלגוריתם של ‪ Prim‬למציאת עץ פורש מינימלי וסרטט את העץ הפורש‬
‫‬
‫‬
‫המינימלי המתקבל עבור הרשת הנתונה‪ ,‬החל מקדקוד ‪.C‬‬
‫ב‪.‬‬
‫(אין קשר לסעיף א‪).‬‬
‫‬
‫‬
‫נתונה הרשת‪:‬‬
‫‬
‫‪D‬‬
‫‪6‬‬
‫‪E‬‬
‫‬
‫‪3‬‬
‫‪15‬‬
‫‪16‬‬
‫‪B‬‬
‫‪9‬‬
‫‪4‬‬
‫‪C‬‬
‫‬
‫‪A‬‬
‫‪2‬‬
‫(‪ )1‬השתמש באלגוריתם של ‪ Kruskal‬למציאת עץ פורש מינימלי וסרטט את‬
‫‬
‫‬
‫העץ הפורש המינימלי של הרשת הנתונה‪.‬‬
‫(‪ )2‬תלמיד הציע למורה אלגוריתם למציאת עץ פורש מינימלי לרשת )‪, G = (V , E‬‬
‫‬
‫‬
‫כאשר ‪ V‬היא קבוצת הקדקודים ו– ‪ E‬היא קבוצת הקשתות של הרשת‪.‬‬
‫‬
‫לפניך האלגוריתם של התלמיד‪.‬‬
‫‬
‫צעד ‪:1‬‬
‫‬
‫‬
‫צעד ‪:2‬‬
‫‬
‫צור גרף ‪ , G1‬שקבוצת הקדקודים שלו היא קבוצת הקדקודים של‬
‫הרשת ‪ G‬וקבוצת הקשתות שלו‪ , E T ,‬היא קבוצה ריקה‪.‬‬
‫‬
‫מיין את קשתות הרשת ‪ G‬בסדר עולה‪ ,‬על פי המשקלות המיוחסים ‬
‫להן‪ .‬תתקבל קבוצת קשתות ממוינות שנסמנה *‪. E‬‬
‫‪/‬המשך בעמוד ‪/25‬‬
‫ ‪- 25‬‬‫צעד ‪:3‬‬
‫‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫לכל קשת )‪ (u , v‬ב– *‪ , E‬החל מהקשת בעלת המשקל‬
‫‬
‫הקטן ביותר‪ ,‬בצע‪:‬‬
‫‬
‫אם הוספת הקשת )‪ (u , v‬אינה יוצרת מעגל ב– ‪ — G1‬הוסף‬
‫‬
‫‬
‫צעד ‪:4‬‬
‫‬
‫את הקשת )‪ (u , v‬ל– ‪. E T‬‬
‫אחרת — החזר את הגרף ‪ G1‬שהינו עץ פורש מינימלי‪.‬‬
‫החזר את ‪ G1‬שהינו עץ פורש מינימלי‪.‬‬
‫‬
‫הפעל את האלגוריתם של התלמיד על הרשת הנתונה‪.‬‬
‫‬
‫ענה על הסעיפים (‪. )iv(-)i‬‬
‫‬
‫(‪ )i‬סרטט במחברתך את ‪ G1‬שנוצר אחרי ביצוע צעד ‪. 1‬‬
‫‬
‫(‪ )ii‬רשום במחברתך את כל הקשתות ב– *‪ E‬אחרי ביצוע צעד ‪. 2‬‬
‫‬
‫(‪ )iii‬סרטט במחברתך כל אחד מהגרפים ‪ G1‬שהתקבלו במהלך צעד ‪. 3‬‬
‫‬
‫‬
‫(‪ )iv‬סרטט במחברתך את העץ הפורש שהאלגוריתם החזיר‪ .‬‬
‫(‪ )3‬המורה השיבה לתלמיד שהאלגוריתם שהוא הציע שגוי‪ ,‬כי הפלט שלו‬
‫אינו בהכרח עץ פורש מינימלי‪ .‬למשל‪ ,‬בעבור הרשת הזו‪:‬‬
‫‬
‫‬
‫‪B‬‬
‫‪A‬‬
‫‪C‬‬
‫‪D‬‬
‫‬
‫אפשר לייחס משקלות לקשתות הרשת כך שאם נשתמש באלגוריתם של התלמיד‬
‫‬
‫לא יוחזר העץ הפורש המינימלי‪.‬‬
‫‬
‫העתק למחברתך את הרשת ורשום משקלות לצִדן של הקשתות‪ ,‬כך שהעץ שיוחזר‬
‫‬
‫על ידי האלגוריתם של התלמיד לא יהיה עץ פורש מינימלי‪.‬‬
‫‬
‫‪/‬המשך בעמוד ‪/26‬‬
‫‪- 26 -‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫‪ .11‬בשאלה זו שני סעיפים א‪-‬ב שאינם תלויים זה בזה‪ .‬ענה על שני הסעיפים‪.‬‬
‫א‪ .‬נתונה בעיית תכנון לינארי‪:‬‬
‫}‪max {z = kx1 + 20x2‬‬
‫‬
‫בכפוף לאילוצים האלה‪:‬‬
‫‬
‫‪ - 3x1 + 4x2 # 24‬‬
‫‬
‫‬
‫‬
‫‪x1 + 2x2 $ 0‬‬
‫‬
‫‪x2 # 5‬‬
‫‬
‫‪x2 $ 0‬‬
‫‬
‫‪ x1‬אינו מוגבל בסימן‪.‬‬
‫‪ k‬הוא פרמטר‪.‬‬
‫לפניך סרטוט של תחום הפתרונות האפשריים של הבעיה הנתונה‪.‬‬
‫‪x2‬‬
‫‬
‫‪6‬‬
‫)‪(- 34 , 5‬‬
‫‬
‫)‪(-4.8 , 2.4‬‬
‫‪x1‬‬
‫‪0‬‬
‫‪-4‬‬
‫‪-8‬‬
‫לפניך ארבעה תת–סעיפים (‪ ,)4(-)1‬שבכל אחד מהם נתון ערך מסוים של הפרמטר ‪.k‬‬
‫‬
‫‬
‫‬
‫(‪. k = 20 )1‬‬
‫(‪. k =-20 )2‬‬
‫‬
‫(‪. k =-15 )3‬‬
‫‬
‫(‪ , k =-15 )4‬ומוסיפים את האילוץ‪. x1#-5 :‬‬
‫‬
‫התת–סעיפים אינם תלויים זה בזה‪.‬‬
‫‬
‫בעבור כל אחד מהתת–סעיפים (‪:)4(-)1‬‬
‫‬
‫‬
‫— אם הפתרון האופטימלי הוא יחיד‪ ,‬עליך למצוא את הפתרון האופטימלי‬
‫‬
‫היחיד‪ ,‬ואת הערך של פונקציית המטרה בפתרון זה‪.‬‬
‫‬
‫— אם יש אין–סוף פתרונות אופטימליים‪ ,‬עליך לרשום את הפתרון האופטימלי ‬
‫‬
‫הכללי לבעיה‪ ,‬ואת הערך של פונקציית המטרה בפתרון זה‪.‬‬
‫‬
‫— אם הפתרון האופטימלי לא חסום‪ ,‬נמק את קביעתך‪.‬‬
‫‬
‫— אם אין פתרון אפשרי‪ ,‬נמק את קביעתך‪.‬‬
‫‬
‫‪/‬המשך בעמוד ‪/27‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫ ‪- 27‬‬‫ב‪( .‬אין קשר לסעיף א‪).‬‬
‫‬
‫‬
‫נתונה בעיית תכנון לינארי‪:‬‬
‫‬
‫‬
‫}‪max {z = ax1 + 3x2‬‬
‫בכפוף לאילוצים האלה‪:‬‬
‫‪ x1 + 83 x2 # 3‬‬
‫‪ x1 + x2 # 5‬‬
‫‪ x1$ 0‬‬
‫‬
‫‬
‫‪ x2 $ 0‬‬
‫‪x2‬‬
‫‪ a 2 0‬הוא פרמטר של הבעיה‪.‬‬
‫לפניך סרטוט של תחום הפתרונות האפשריים של הבעיה הנתונה‪.‬‬
‫‪8‬‬
‫‬
‫‪5‬‬
‫‬
‫)‪(1.8 , 3.2‬‬
‫‪x1‬‬
‫‪5‬‬
‫‪3‬‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫לפניך ארבעה תחומים‪ , iv-i ,‬בעבור הפרמטר ‪: a‬‬
‫‪a 13‬‬
‫‪i‬‬
‫‪a 28‬‬
‫‪ii‬‬
‫‪3 1 a 1 8 iii‬‬
‫‪3 1 a 1 24 iv‬‬
‫‬
‫‬
‫קבע בעבור איזה מבין התחומים ‪ , iv-i‬הפתרון )‪ (1.8 , 3.2‬יהיה‬
‫פתרון אופטימלי יחיד‪ .‬העתק את התחום למחברתך‪ ,‬ונמק את קביעתך‪.‬‬
‫‪0‬‬
‫‪/‬המשך בעמוד ‪/28‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫‪- 28 -‬‬
‫‪ .12‬בשאלה זו חמישה סעיפים‪ ,‬א‪-‬ה‪ ,‬שאינם תלויים זה בזה‪ .‬ענה על כל הסעיפים‪.‬‬
‫א‪ .‬בטבלה שלפניך נתון חלק מפתרון בסיסי אפשרי לבעיית התובלה‪:‬‬
‫‬
‫‪. x21 = 20 , x11 = 80‬‬
‫ ‬
‫יעדים‬
‫מקורות‬
‫היצע‬
‫‪3‬‬
‫‪80‬‬
‫‪1‬‬
‫‪2‬‬
‫‪17‬‬
‫‪15‬‬
‫‪14‬‬
‫‪18‬‬
‫‪18‬‬
‫‪20‬‬
‫‪10‬‬
‫‪1‬‬
‫‪80‬‬
‫‪120‬‬
‫‪10‬‬
‫‪2‬‬
‫‪20‬‬
‫‪50‬‬
‫‪50‬‬
‫‪15‬‬
‫‪100‬‬
‫‪3‬‬
‫‪100‬‬
‫ביקוש‬
‫העתק את הטבלה למחברתך‪ ,‬והשלם אותה לפי שיטת הפינה הצפונית מערבית‪.‬‬
‫‬
‫‬
‫ב‪.‬‬
‫בטבלה שלפניך נתון חלק מפתרון בסיסי אפשרי לבעיית תובלה‪ ,‬ונתונים ערכים של‬
‫‪. u3 , u2 , u1 , v3 , v2 , v1‬‬
‫‪ui‬‬
‫היצע‬
‫‪0‬‬
‫‪80‬‬
‫‪3‬‬
‫‪100‬‬
‫‪-5‬‬
‫‪50‬‬
‫יעדים‬
‫‪3‬‬
‫‪12‬‬
‫‪2‬‬
‫‪15‬‬
‫‪1‬‬
‫מקורות‬
‫‪10‬‬
‫‪80‬‬
‫‪10‬‬
‫‪14‬‬
‫‪18‬‬
‫‪100‬‬
‫‪10‬‬
‫‪20‬‬
‫‪10‬‬
‫‪50‬‬
‫‪50‬‬
‫‪100‬‬
‫‪80‬‬
‫‪19‬‬
‫‪15‬‬
‫‪10‬‬
‫‪1‬‬
‫‪2‬‬
‫‪3‬‬
‫ביקוש‬
‫‪vj‬‬
‫העתק את הטבלה למחברתך‪ ,‬והשלם אותה לפי שיטת הפינה הצפונית מערבית מתוך‬
‫התחשבות בערכים של ‪– u i‬ים ו– ‪– v j‬ים‪ ,‬כך שיתקבל פתרון בסיסי אפשרי‪.‬‬
‫‪/‬המשך בעמוד ‪/29‬‬
‫‬
‫ ‪- 29‬‬‫ג‪.‬‬
‫‬
‫‬
‫‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫בטבלה שלפניך נתון פתרון בסיסי אפשרי לבעיית תובלה‪ ,‬ונתונים ערכים של‬
‫‪. u3 , u2 , u1 , v3 , v2 , v1‬‬
‫יעדים‬
‫‪ui‬‬
‫היצע‬
‫‪0‬‬
‫‪130‬‬
‫‪-4‬‬
‫‪100‬‬
‫‪1‬‬
‫‪150‬‬
‫‪2‬‬
‫‪3‬‬
‫‪13‬‬
‫מקורות‬
‫‪1‬‬
‫‪18‬‬
‫‪30‬‬
‫‪10‬‬
‫‪100‬‬
‫‪12‬‬
‫‪6‬‬
‫‪21‬‬
‫‪100‬‬
‫‪14‬‬
‫‪100‬‬
‫‪11‬‬
‫‪16‬‬
‫‪50‬‬
‫‪1‬‬
‫‪2‬‬
‫‪3‬‬
‫‪130‬‬
‫‪50‬‬
‫‪200‬‬
‫ביקוש‬
‫‪13‬‬
‫‪15‬‬
‫‪10‬‬
‫‪vj‬‬
‫האם הפתרון הוא אופטימלי? נמק את תשובתך‪.‬‬
‫‬
‫‬
‫‬
‫‪/‬המשך בעמוד ‪/30‬‬
‫ ‪- 30‬‬‫ד‪.‬‬
‫‬
‫‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫בטבלה שלפניך נתון פתרון אופטימלי לבעיית תובלה‪ ,‬ונתונים ערכים של‬
‫‪ , u3 , u2 , u1 , v3 , v2 , v1‬שמתאימים לפתרון זה‪.‬‬
‫יעדים‬
‫‪ui‬‬
‫היצע‬
‫‪10‬‬
‫‪20‬‬
‫‪10‬‬
‫‪50‬‬
‫‪16‬‬
‫‪60‬‬
‫‪2‬‬
‫‪3‬‬
‫מקורות‬
‫‪1‬‬
‫‪16‬‬
‫‪25‬‬
‫‪14‬‬
‫‪22‬‬
‫‪10‬‬
‫‪20‬‬
‫‪30‬‬
‫‪20‬‬
‫‪20‬‬
‫‪20‬‬
‫‪10‬‬
‫‪18‬‬
‫‪20‬‬
‫‪40‬‬
‫‪1‬‬
‫‪2‬‬
‫‪3‬‬
‫‪40‬‬
‫‪40‬‬
‫‪50‬‬
‫ביקוש‬
‫‪4‬‬
‫‪4‬‬
‫‪0‬‬
‫‪vj‬‬
‫‬
‫(‪ )1‬האם הפתרון הנתון הוא אופטימלי יחיד? נמק את תשובתך‪.‬‬
‫‬
‫(‪ )2‬בטבלה הנתונה בראש הסעיף ַה ְחסֵר ‪ 4‬מהעלות ליחידה מכל מקור לכל יעד‪.‬‬
‫‬
‫סרטט את הטבלה שתתקבל‪.‬‬
‫‬
‫קבע איזה מארבעת ההיגדים ‪ iv-i‬שלפניך הוא הנכון‪.‬‬
‫‬
‫העתק אותו למחברתך‪ ,‬ונמק את בחירתך‪.‬‬
‫‬
‫‪i‬‬
‫הפתרון הנתון אינו פתרון אפשרי בעבור הבעיה שהתקבלה‪.‬‬
‫‬
‫‪ii‬‬
‫הפתרון הנתון הוא פתרון בסיסי אפשרי אך אינו אופטימלי בעבור‬
‫‬
‫‬
‫הבעיה שהתקבלה‪.‬‬
‫‪iii‬‬
‫‬
‫‬
‫‬
‫‬
‫הפתרון הנתון הוא פתרון אופטימלי יחיד בעבור הבעיה שהתקבלה‪.‬‬
‫‪ iv‬הפתרון הנתון הוא פתרון אופטימלי אך אינו פתרון אופטימלי יחיד בעבור ‬
‫הבעיה שהתקבלה‪.‬‬
‫‪/‬המשך בעמוד ‪/31‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫ ‪- 31‬‬‫ה‪.‬‬
‫בטבלה שלפניך נתון פתרון לא אופטימלי שהתקבל לאחר ‪ k‬איטרציות בעבור‬
‫‬
‫בעיית תובלה מסוימת‪ ,‬ונתונים ערכים של ‪. u3 , u2 , u1 , v 4 , v3 , v2 , v1‬‬
‫יעדים‬
‫‪ui‬‬
‫היצע‬
‫‪0‬‬
‫‪230‬‬
‫‪-3‬‬
‫‪150‬‬
‫‪-5‬‬
‫‪540‬‬
‫‪Z = 3070‬‬
‫‬
‫‪4‬‬
‫‪3‬‬
‫‪2‬‬
‫‪2‬‬
‫‪4‬‬
‫‪-6‬‬
‫‪3‬‬
‫‪2‬‬
‫‪5‬‬
‫‪3‬‬
‫‪340‬‬
‫‪200‬‬
‫‪2‬‬
‫‪70‬‬
‫‪3‬‬
‫‪3‬‬
‫‪5‬‬
‫‪150‬‬
‫‪4‬‬
‫‪80‬‬
‫‪-2‬‬
‫‪1‬‬
‫‪80‬‬
‫‪-4‬‬
‫מקורות‬
‫‪4‬‬
‫‪7‬‬
‫‪7‬‬
‫‪7‬‬
‫‪340‬‬
‫‪280‬‬
‫‪80‬‬
‫‪220‬‬
‫‪8‬‬
‫‪8‬‬
‫‪2‬‬
‫‪5‬‬
‫‪1‬‬
‫‪2‬‬
‫‪3‬‬
‫ביקוש‬
‫‪vj‬‬
‫הפתרון המתואר בטבלה זו אינו אופטימלי כיוון שיש משתנים מחוץ לבסיס‬
‫שערך ה– ) ‪ (c ij - u i - v j‬שלהם שלילי‪.‬‬
‫עליך לבצע איטרציה נוספת‪ ,‬כלומר איטרציה ‪. k + 1‬‬
‫‬
‫(‪ )1‬מהו המשתנה שיוצא מהבסיס באיטרציה זו?‬
‫‬
‫(‪ )2‬סרטט במחברתך טבלה חדשה‪ ,‬ורשום בה את הפתרון שיתקבל לאחר‬
‫‬
‫איטרציה זו‪.‬‬
‫‪/‬המשך בעמוד ‪/32‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫ ‪- 32‬‬‫מודלים חישוביים‬
‫אם למדת מסלול זה‪ ,‬ענה על שתיים מהשאלות ‪( 16-13‬לכל שאלה — ‪ 25‬נקודות)‪.‬‬
‫‪ .13‬לפניך השפה ‪ L‬מעל הא"ב ‪: " a , b , c ,‬‬
‫‪L = {a n b3k+1 c k‬‬
‫}‪n 2 0 , k 2 0‬‬
‫‬
‫‬
‫א‪.‬‬
‫כתוב את המילה הקצרה ביותר בשפה ‪. L‬‬
‫‬
‫ב‪.‬‬
‫בנה אוטומט מחסנית שיקבל את השפה ‪. L‬‬
‫‪ .14‬בשאלה זו שני סעיפים א‪-‬ב‪ ,‬שאין קשר ביניהם‪ .‬ענה על שניהם‪.‬‬
‫לפניך השפה ‪ L‬מעל הא"ב }‪: {a , b‬‬
‫א‪.‬‬
‫‬
‫‬
‫‬
‫} התו האחרון ב– ‪ w‬מופיע בכל המילה מספר זוגי של פעמים‪w 2 0 ,‬‬
‫‪L = {w‬‬
‫לדוגמא‪:‬‬
‫‬
‫המילה ‪ abaabbab‬שייכת לשפה‪.‬‬
‫‬
‫המילה ‪ abbabaa‬שייכת לשפה‪.‬‬
‫‬
‫‬
‫‬
‫המילה ‪ babbaba‬לא שייכת לשפה‪.‬‬
‫לפניך סרטוט חלקי של אוטומט סופי דטרמיניסטי המקבל את השפה ‪. L‬‬
‫‬
‫בסרטוט חסרים מעברים וסימני קלט‪.‬‬
‫‪b‬‬
‫‪q6‬‬
‫‬
‫‬
‫‪b‬‬
‫‪a‬‬
‫‪q4‬‬
‫‪q5‬‬
‫‪a‬‬
‫‪q1‬‬
‫‪q3‬‬
‫‪b‬‬
‫‪a‬‬
‫‪q0‬‬
‫‪q2‬‬
‫‪‰ÏÁ˙‰‬‬
‫‪b‬‬
‫‬
‫הסרטוט מכיל את כל המצבים של האוטומט‪ ,‬ואת כל המצבים המקבלים‪.‬‬
‫‬
‫העתק למחברתך את הסרטוט‪ ,‬והשלם אותו כך שהאוטומט יקבל את השפה ‪. L‬‬
‫‬
‫עליך להשלים את המעברים החסרים ואת סימני הקלט החסרים‪.‬‬
‫‬
‫שים לב‪ :‬אין להוסיף מצבים לאוטומט או להוריד ממנו מצבים‪.‬‬
‫‪/‬המשך בעמוד ‪/33‬‬
‫ ‪- 33‬‬‫ב‪.‬‬
‫‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫(אין קשר לסעיף א‪).‬‬
‫לפניך אוטומט סופי דטרמיניסטי המקבל את שפה ‪ L‬מעל הא"ב }‪. {a , b‬‬
‫‬
‫‬
‫‪a‬‬
‫‪a‬‬
‫‪q2‬‬
‫‪a‬‬
‫‪b‬‬
‫‬
‫‪b‬‬
‫‪q4‬‬
‫‪q1‬‬
‫‪b a‬‬
‫‪b‬‬
‫‪q3‬‬
‫‪a‬‬
‫‪q0‬‬
‫‪‰ÏÁ˙‰‬‬
‫‪b‬‬
‫(‪ )1‬קבע לכל אחת מארבע המילים (‪ )iv(-)i‬שלפניך אם היא מתקבלת על ידי‬
‫‬
‫‬
‫האוטומט‪ .‬אם המילה מתקבלת על ידי האוטומט‪ ,‬רשום את המסלול המקבל‬
‫‬
‫בעבור מילה זו‪.‬‬
‫‬
‫(‪)i‬‬
‫‪aaba‬‬
‫‬
‫(‪)ii‬‬
‫‪bbaabb‬‬
‫‬
‫(‪)iii‬‬
‫‪abaa‬‬
‫‬
‫(‪)iv‬‬
‫‪bb‬‬
‫(‪ )2‬מהי השפה ‪ L‬המוגדרת על ידי האוטומט?‬
‫‬
‫‪ .15‬לפניך השפה ‪ L‬מעל הא"ב }‪: {0 , 1 , 2‬‬
‫}‪n 2 k $ 0‬‬
‫‬
‫א‪.‬‬
‫הוכח כי השפה ‪ L‬אינה רגולרית‪.‬‬
‫‬
‫ב‪.‬‬
‫נתונה השפה ‪ L1‬מעל הא"ב }‪: {1 , 2‬‬
‫‬
‫‬
‫מהי השפה ‪ ? L1+ L‬נמק‪.‬‬
‫‪L = {0 n 1 k 2‬‬
‫}‪L1 = {1 n 2 n $ 0‬‬
‫‬
‫‪/‬המשך בעמוד ‪/34‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫‪- 34 -‬‬
‫‪ .16‬לפניך מכונת טיורינג המחשבת פונקציה )‪. f(x‬‬
‫המכונה מקבלת כקלט מספר ‪ x‬שלם וגדול מ– ‪ , 0‬הרשום על הסרט כמספר אונרי על ידי‬
‫‬
‫‪ x‬תווים של ‪ ,1‬ואחריהם הסימן ‪. T‬‬
‫‬
‫המכונה רושמת את תוצאת החישוב של )‪ f(x‬על הסרט כמספר אונרי אחרי הסימן = ‪,‬‬
‫‬
‫ולאחר המספר מופיע הסימן ‪. T‬‬
‫‪1/1,ÔÈÓÈ‬‬
‫‬
‫‪q2 D/D,Ï‡Ó˘ q3‬‬
‫‬
‫˘‪1/D,χÓ‬‬
‫˘‪D/D,χÓ‬‬
‫‪1/a,ÔÈÓÈ‬‬
‫‪a/1,ÔÈÓÈ q‬‬
‫‪6‬‬
‫˘‪1/1,χÓ‬‬
‫‪q1 1/1,ÔÈÓÈ‬‬
‫‪q0 1/a,ÔÈÓÈ‬‬
‫‪q5‬‬
‫‪‰ÏÁ˙‰‬‬
‫‬
‫‪q4‬‬
‫˘‪a/D,χÓ‬‬
‫˘‪D/D,χÓ‬‬
‫‪q7‬‬
‫א‪.‬‬
‫מה יכיל הסרט לאחר חישוב )‪ ?f(3‬הראה את מסלול החישוב של המכונה‪.‬‬
‫בכל שלב רשום את מצב הסרט‪ ,‬סמן היכן נמצא ראש המכונה‪ ,‬ורשום‬
‫באיזה מהמצבים ‪ q7 - q0‬המכונה נמצאת‪.‬‬
‫ב‪.‬‬
‫מה יכיל הסרט לאחר חישוב )‪? f (5‬‬
‫‬
‫ג‪.‬‬
‫מה יכיל הסרט לאחר חישוב )‪? f (6‬‬
‫‬
‫ד‪.‬‬
‫מהי הפונקציה )‪ f(x‬שהמכונה מחשבת?‬
‫‬
‫ה‪.‬‬
‫‬
‫‬
‫הוסף למכונה מעבר‪/‬מעברים כדי שתחשב גם את )‪. f (0‬‬
‫כתוב במחברתך את המעבר‪/‬מעברים שהוספת‪.‬‬
‫לכל מעבר רשום‪ :‬מאיזה מצב הוא יוצא‪ ,‬לאיזה מצב הוא מגיע ומה רשום עליו‪.‬‬
‫‬
‫‪/‬המשך בעמוד ‪/35‬‬
‫‪- 35 -‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫שים לב‪ :‬תכנות מונחה עצמים מתחיל בעמוד ‪.36‬‬
603 ,899205 '‫ מס‬,‫ קיץ תשע"א‬,'‫מדעי המחשב ב‬
- 36 -
‫תכנות מונחה עצמים‬
.20-17 ‫ ענה על שתיים מהשאלות‬,Java –‫אם למדת מסלול זה ואתה כותב ב‬
)‫ נקודות‬25 — ‫(לכל שאלה‬
: BB –‫ ו‬AA ‫ לפניך המחלקות‬.17
public class AA
{
private String st;
public AA()
{ this.st = "excellent"; }
public AA(String st)
{ this.st = st;
}
public String getSt()
{ return this.st;
}
public void setSt(String st)
{ this.st = st;
}
}
public String toString()
{ return "st = " + this.st; }
public class BB extends AA
{
private int num;
public BB() { super(); this.num = 1; }
public BB(int num , String st) { super(st); this.num = math.abs(num);
public int getNum() { return this.num; }
public void setNum(int num) { this.num = num;
}
}
public String toString() { return super.toString() + " num = " + this.num;}
obj ‫ המקבלת עצם‬isLike(Object obj) ‫ פעולה בוליאנית בשם‬AA ‫הגדר במחלקה‬
}
.‫א‬
obj ‫ של‬st ‫ וגם תוכן המחרוזת‬AA ‫ הינו מטיפוס‬obj ‫ אם העצם‬. Object ‫מטיפוס‬
. false ‫ אחרת — תחזיר‬,true ‫ של העצם הנוכחי — הפעולה תחזיר‬st ‫זהה לתוכן המחרוזת‬
.‫ פעולה הדורסת את הפעולה שהגדרת בסעיף א‬BB ‫הגדר במחלקה‬
.‫ב‬
num ‫ שלו זהה לערך התכונה‬num ‫ וגם ערך התכונה‬BB ‫ הינו מטיפוס‬obj ‫אם העצם‬
.false ‫ אחרת — תחזיר‬, true ‫של העצם הנוכחי — הפעולה תחזיר‬
/37 ‫המשך בעמוד‬/
‫ ‪- 37‬‬‫ג‪.‬‬
‫לפניך קטע מפעולה ראשית‪:‬‬
‫‬
‫האם קטע התכנית תקין?‬
‫‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫;)"‪AA a = new AA("excellent‬‬
‫;)(‪BB b = new BB‬‬
‫;‪a = b‬‬
‫;)‪if (a.isLike(b)) System.out.println(a‬‬
‫אם כן — מה יהיה פלט הקטע? רשום איזו גרסה של הפעולה ‪ isLike‬תופעל — זו של‬
‫‪ AA‬או זו של ‪. BB‬‬
‫‬
‫‬
‫אם לא — הסבר מהי השגיאה ומתי היא תתגלה‪ :‬בזמן קומפילציה או בזמן ריצה‪.‬‬
‫ד‪.‬‬
‫לפניך קטע מפעולה ראשית‪:‬‬
‫;)(‪AA aa = new AA‬‬
‫;)"‪BB bb = new BB(2 , "excellent‬‬
‫;‪bb = aa‬‬
‫;)‪if (bb.isLike(aa)) System.out.println(bb‬‬
‫‬
‫האם קטע התכנית תקין?‬
‫‬
‫אם כן — מה יהיה פלט הקטע? רשום איזו גרסה של הפעולה ‪ isLike‬תופעל — זו של‬
‫‬
‫‪ AA‬או זו של ‪. BB‬‬
‫אם לא — הסבר מהי השגיאה ומתי היא תתגלה‪ :‬בזמן קומפילציה או בזמן ריצה‪.‬‬
‫‬
‫ה‪.‬‬
‫כתוב פעולה חיצונית בשם ‪ longString‬המקבלת מערך של עצמים מטיפוס ‪. object‬‬
‫‬
‫הפעולה מחזירה מחרוזת המורכבת משרשור התכונה ‪ st‬של עצמים מטיפוס ‪AA‬‬
‫‬
‫במערך‪ ,‬באופן הזה‪:‬‬
‫‬
‫‬
‫— אם לעצם יש רק התכונה ‪ ,st‬תשורשר המחרוזת שבתכונה ‪ st‬פעם אחת‪.‬‬
‫‬
‫— אם לעצם יש גם התכונה ‪ ,num‬המחרוזת שבתכונה ‪ st‬תשורשר ‪ num‬פעמים‪.‬‬
‫‬
‫— אם אין במערך אף עצם מטיפוס ‪ ,AA‬תוחזר מחרוזת ריקה‪.‬‬
‫‬
‫‬
‫‪/‬המשך בעמוד ‪/38‬‬
603 ,899205 '‫ מס‬,‫ קיץ תשע"א‬,'‫מדעי המחשב ב‬
public class B
{
private static int numB = 0;
private int m1;
private int m2;
public B(int m1, int m2)
{
}
}
- 38 -
:OopTest –‫ ו‬A , D , B :‫ לפניך פרויקט ובו המחלקות‬.18
this.m1 = m1;
this.m2 = m2;
numB++;
System.out.println("B(" + m1 + ", " + m2 + ") , #" + numB);
public class D extends B
{
private static int numD = 0;
private double d;
public D(double d, int x)
{
}
public D(double d, int x, int y)
{
}
}
super(x, x);
this.d = d;
numD++;
System.out.println("D(" + d + ", " + x + ") , #" + numD);
super(x , y);
this.d = d;
numD++;
System.out.println("D(" + d +", "+ x + " , " + y + ") , #" + numD);
/39 ‫המשך בעמוד‬/
603 ,899205 '‫ מס‬,‫ קיץ תשע"א‬,'‫מדעי המחשב ב‬
- 39 -
public class A
{
private static int numA = 0;
private A a;
private B b;
public A(A a , B b)
{
this.a = a;
this.b = b;
numA++;
System.out.println("A Constructor , #" + numA);
}
}
public class OopTest
{
public static void main(String [] args)
{
B w1 = new B(2, 3);
B w2 = new D(1.5 , 6);
B w3 = new D(2.3 , 8 , 9);
A w4 = new A(null , w1);
A w5 = new A(w4 , w3);
}
}
.‫ וכתוב את הפלט‬, OopTest ‫ במחלקה‬main ‫כתוב מעקב אחר הפעולה‬
.‫ ובעבור כל עצם — את ערכי התכונות שלו‬,‫במעקב יש לכתוב את ערכי המשתנים‬
/40 ‫המשך בעמוד‬/
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫‪- 40 -‬‬
‫‪ .19‬חברה המפיצה לומדות פיתחה לומדה העוסקת בסדרות של מספרים שלמים‪.‬‬
‫המערכת פותחה בשלבים‪.‬‬
‫‬
‫בכל סדרה של מספרים מתייחסים אל‪:‬‬
‫‬
‫(‪ )1‬האיבר הראשון בסדרה שמספרו הסידורי הוא ‪.1‬‬
‫‬
‫(‪ )2‬האיבר שמספרו הסידורי בסדרה הוא ‪. n‬‬
‫‬
‫(‪ )3‬הדפסת ‪ n‬האיברים הראשונים בסדרה‪.‬‬
‫‬
‫בשלב הראשון פותחו שתי מחלקות‪:‬‬
‫‬
‫סדרה חשבונית )‪ — (ASeq‬סדרה שבה ההפרש בין כל איבר לקודמו הוא ערך קבוע‪.‬‬
‫‬
‫סדרה הנדסית )‪ — (GSeq‬סדרה שבה המנה בין כל איבר לקודמו היא ערך קבוע‪.‬‬
‫‬
‫להלן קוד המחלקות שפותחו בשלב הראשון‪:‬‬
‫‪public class ASeq‬‬
‫{‬
‫;‪private int first‬‬
‫‬
‫;‪private int difference‬‬
‫‬
‫‬
‫)‪public ASeq(int first, int difference‬‬
‫‬
‫{‬
‫‬
‫;‪this.first = first‬‬
‫‬
‫;‪this.difference = difference‬‬
‫‬
‫}‬
‫‬
‫)‪public int theNElement(int n‬‬
‫‬
‫{‬
‫‬
‫;‪return this.first + (n-1) * this.difference‬‬
‫‬
‫}‬
‫‬
‫‪/‬המשך בעמוד ‪/41‬‬
603 ,899205 '‫ מס‬,‫ קיץ תשע"א‬,'‫מדעי המחשב ב‬
- 41 -
public void displayNElements(int n)
{
System.out.print("The sequence elements: ");
for (int i = 0; i < n-1; i++)
System.out.print(this.theNElement(i+1) + " , ");
System.out.println(this.theNElement(n));
}
}
public class GSeq
{
private int first;
private int product;
public GSeq(int first , int product)
{
this.first = first;
this.product = product;
}
public int theNElement(int n)
{
return this.first * (int)Math.pow(this.product , n-1);
}
public void displayNElements(int n)
{
System.out.print("The sequence elements: ");
for (int i = 0 ; i < n-1; i++)
System.out.print(this.theNElement(i+1) + " , ");
System.out.println(this.theNElement(n));
}
}
/42 ‫המשך בעמוד‬/
).‫ המשך השאלה בעמוד הבא‬:‫(שים לב‬
‫ ‪- 42‬‬‫א‪.‬‬
‫‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫עקוב אחר קטע התכנית שלפניך‪ .‬במעקב הצג את העצם שנבנה‪ ,‬את התכונות שלו‬
‫ואת הפלט‪.‬‬
‫‬
‫;)‪ASeq aSeq = new ASeq(2 , 3‬‬
‫;))‪System.out.println(aSeq.theNElement(4‬‬
‫;)‪aSeq.displayNElements(5‬‬
‫‬
‫בשלב השני של הפיתוח הוחלט שמתאים לפתח מחלקה חדשה המתארת סדרה קבועה‬
‫)‪ ,(Sequence‬כך שהמחלקות ‪ ASeq‬ו– ‪ GSeq‬יירשו מן המחלקה החדשה‪ .‬בסדרה קבועה‬
‫מוגדר ערך האיבר הראשון‪ ,‬וכל יתר האיברים זהים לאיבר הראשון‪.‬‬
‫ב‪.‬‬
‫השלם את הפיתוח של השלב השני באופן המתאים ביותר לעקרונות של תכנות‬
‫‬
‫מונחה עצמים‪ ,‬ובהתאם להנחיות )‪:(ii)-(i‬‬
‫‬
‫)‪( i‬‬
‫‬
‫ממש באופן מלא את מחלקת העל ‪ .Sequence‬המחלקה צריכה להתייחס אל‪:‬‬
‫‬
‫(‪)1‬‬
‫האיבר הראשון בסדרה שמספרו הסידורי ‪.1‬‬
‫‬
‫(‪)2‬‬
‫האיבר שמספרו הסידורי בסדרה הוא ‪. n‬‬
‫‬
‫(‪)3‬‬
‫הדפסת ‪ n‬האיברים הראשונים של הסדרה‪.‬‬
‫)‪ (ii‬ממש מחדש את המחלקה ‪ ASeq‬כך שתירש מן המחלקה ‪. Sequence‬‬
‫‬
‫בשלב השלישי של הפיתוח הוחלט להרחיב את הפרויקט שכולל את שלוש המחלקות‬
‫‬
‫שפותחו בשלב השני )‪ ,(Sequence , ASeq , GSeq‬כך שבעבור כל סדרה יהיה אפשר‬
‫להפעיל פעולה המחשבת ומחזירה את סכום ‪ n‬האיברים הראשונים של הסדרה‪.‬‬
‫הנח כי המחלקה ‪ GSeq‬מומשה מחדש‪ ,‬כך שהיא יורשת מן המחלקה ‪. Sequence‬‬
‫ג‪.‬‬
‫בעבור כל אחת מן המחלקות ‪ , Sequence, ASeq , GSeq‬כתוב אם יש‬
‫‬
‫לעשות בה שינוים כך שהפרויקט יענה על דרישות הפיתוח של השלב השלישי‬
‫‬
‫באופן המתאים ביותר לעקרונות של תכנות מונחה עצמים‪.‬‬
‫‬
‫אם יש לעשות שינויים — פרט וממש אותם‪.‬‬
‫‪/‬המשך בעמוד ‪/43‬‬
‫‪- 43 -‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫בשלב הרביעי של הפיתוח הוחלט לפתח פעולה סטטית ‪ check‬המקבלת ערך שלם ‪, n‬‬
‫‬
‫ושני עצמים של סדרות‪ :‬האחד מטיפוס ‪ ASeq‬והאחר מטיפוס ‪. GSeq‬‬
‫הפעולה מחשבת את סכום ‪ n‬האיברים הראשונים בכל אחת משתי הסדרות ומחזירה‪:‬‬
‫—‬
‫את התו '‪ — 'A‬אם סכום ‪ n‬האיברים הראשונים של הסדרה מטיפוס ‪ ASeq‬‬
‫‬
‫הוא הגדול מבין שני הסכומים‪.‬‬
‫—‬
‫את התו '‪ — 'G‬אם סכום ‪ n‬האיברים הראשונים של הסדרה מטיפוס ‪ GSeq‬‬
‫‬
‫הוא הגדול מבין שני הסכומים‪.‬‬
‫‬
‫—‬
‫את התו '‪ — 'E‬אם סכום ‪ n‬האיברים הראשונים של שתי הסדרות שווה‪.‬‬
‫‬
‫ד‪.‬‬
‫ממש את הפעולה הסטטית ‪ check‬על פי הדרישות שהוגדרו בשלב הרביעי‬
‫‬
‫של הפיתוח‪.‬‬
‫‬
‫‬
‫‪/‬המשך בעמוד ‪/44‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫‪- 44 -‬‬
‫‪ .20‬מרפאה וטרינרית של חיות מחמד מרכזת מידע על הווטרינרים העובדים במרפאה ועל‬
‫חיות המחמד המטופלות בה‪ .‬מספר הווטרינרים העובדים במרפאה הוא לכל היותר ‪, 10‬‬
‫ומספר חיות המחמד המטופלות במרפאה הוא לכל היותר ‪. 500‬‬
‫‬
‫הקווים המנחים לניהול המידע הם‪:‬‬
‫‬
‫•‬
‫•‬
‫‬
‫‬
‫•‬
‫‬
‫לכל וטרינר נשמר‪ :‬מספר תעודת הזהות‪ ,‬שם‪ ,‬ותק בעבודה בשנים‪.‬‬
‫‬
‫לכל חיית מחמד נשמר‪ :‬מספר הרישוי‪ ,‬שם‪ ,‬סוג (למשל‪ :‬כלב‪ ,‬חתול או ארנב)‪,‬‬
‫גיל‪ ,‬פירוט של עד ‪ 50‬הביקורים האחרונים במרפאה‪ ,‬מספר הביקורים השמורים‪.‬‬
‫לכל ביקור במרפאה נשמר‪ :‬מספר תעודת הזהות של הווטרינר שטיפל בחיית המחמד‬
‫‬
‫בביקור זה‪ ,‬ומחרוזת של תווים המכילה קודים של טיפולים שחיית המחמד קיבלה‬
‫‬
‫באותו ביקור‪ .‬קוד של טיפול הוא אות גדולה מתוך כל אותיות ה– ‪. ABC‬‬
‫חלק מהפעולות שהמערכת יכולה לבצע הן‪:‬‬
‫•‬
‫‬
‫‬
‫הדוח יכלול את מספר הרישוי שלה‪ ,‬את שמה ואת גילה‪.‬‬
‫•‬
‫‬
‫הפקת דוח של כל חיות המחמד מסוג מסוים (למשל כל הארנבים)‪ .‬לכל חיה‬
‫‬
‫בתחילת כל שנה‪ :‬עדכון הגיל של כל חיית מחמד‪ ,‬כלומר הגדלת הגיל ב–‪, 1‬‬
‫ועדכון הוותק של כל וטרינר‪ ,‬כלומר הגדלת הוותק ב–‪. 1‬‬
‫‬
‫•‬
‫‬
‫לפניך תרשים של היררכיית המחלקות הנדרשות בעבור ניהול המידע של המרפאה‪:‬‬
‫החזרת שם של וטרינר על פי מספר תעודת הזהות שלו‪.‬‬
‫‬
‫‪Clinic‬‬
‫‪˙‡ ˙‚ˆÈÈÓ‬‬
‫‪‰‡Ù¯Ó‰‬‬
‫‪Vet‬‬
‫‪¯ȯË ˙‚ˆÈÈÓ‬‬
‫‪ÔÓÈÒ‰‬‬
‫‪Animal‬‬
‫‪˙‚ˆÈÈÓ‬‬
‫‪„ÓÁÓ ˙ÈÈÁ‬‬
‫‪Appointment‬‬
‫‪¯Â˜È· ˙‚ˆÈÈÓ‬‬
‫‡ˆ‪¯ȯË Ï‬‬
‫·˙¯˘‪ƉÏΉ ‚ˆÈÈÓ ÌÈ‬‬
‫‪/‬המשך בעמוד ‪/45‬‬
‫ ‪- 45‬‬‫א‪.‬‬
‫‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫בעבור כל מחלקה בתרשים‪ ,‬הגדר את התכונות ואת הפעולות שלה‪.‬‬
‫‬
‫‬
‫עליך להגדיר רק את הפעולות הנחוצות כדי לענות על הדרישות שתוארו בפתיח‬
‫‬
‫לשאלה (שבעמוד ‪ )44‬ובתרשים‪.‬‬
‫‬
‫הנח שנתונות פעולות בונות‪ ,‬המקבלות פרמטר לכל תכונה‪ ,‬ופעולות מאחזרות‬
‫‬
‫(פעולות ‪ ,)get‬ואין צורך לכתוב אותן‪ .‬לא נתונות פעולות קובעות (פעולות ‪. )set‬‬
‫‬
‫בעבור כל תכונה — רשום את ההגדרה שלה ב– ‪ , Java‬ורשום את התיעוד שלה‪.‬‬
‫‬
‫בעבור כל פעולה — רשום את הכותרת שלה ב– ‪ , Java‬ורשום תיעוד הכולל‬
‫‬
‫מה היא מקבלת ומה היא מחזירה‪ .‬אין צורך לממש את הפעולה‪.‬‬
‫ב‪.‬‬
‫הנח כי המערכת פותחה בהתאם לתכנון שהצגת בסעיף א‪ ,‬וכל הפעולות הנתונות‬
‫‬
‫ואלו שהגדרת ממומשות‪.‬‬
‫‬
‫במחלקה ‪ Clinic‬מוסיפים את הפעולה‪:‬‬
‫‬
‫)‪public void addAppointment (Animal p , String t , Vet v‬‬
‫‬
‫‬
‫המקבלת חיית מחמד ‪ , p‬מחרוזת ‪ t‬של קודים של טיפולים שקיבלה החיה בביקור‬
‫הנוכחי‪ ,‬ואת הווטרינר ‪ v‬שטיפל בה‪ .‬הפעולה מוסיפה את הביקור לחיית המחמד‪.‬‬
‫‬
‫ממש באופן מלא את הפעולה‪.‬‬
‫‬
‫הנח שמספר הביקורים הקודמים של החיה במרפאה קטן מ–‪. 50‬‬
‫‬
‫אם נוסף על הפעולות הנתונות ועל הפעולות שהגדרת בסעיף א אתה משתמש‬
‫‬
‫בפעולות אחרות‪ ,‬עליך לממש אותן באופן מלא ולציין בעבור כל פעולה באיזו‬
‫‬
‫מחלקה יש לממש אותה‪.‬‬
‫‪/‬המשך בעמוד ‪/46‬‬
603 ,899205 '‫ מס‬,‫ קיץ תשע"א‬,'‫מדעי המחשב ב‬
- 46 -
‫תכנות מונחה עצמים‬
.24-21 ‫ ענה על שתיים מהשאלות‬,C# –‫אם למדת מסלול זה ואתה כותב ב‬
)‫ נקודות‬25 — ‫(לכל שאלה‬
:BB–‫ ו‬AA ‫ לפניך המחלקות‬.21
public class AA
{
private string st;
public AA()
{ this.st = "excellent"; }
public AA(string st)
{ this.st = st;
}
public string GetSt()
public void SetSt (string st)
{ return this.st;
{ this.st = st;
}
}
}
public override string ToString() { return "st = " + this.st; }
public class BB : AA
{
private int num;
public BB() : base()
public BB(int num, string st) : base(st) {this.num = Math.abs(num);
{this.num = 1; }
}
public int GetNum()
{return this.num;}
public override string ToString()
{ return base.toString() + " num = "
public void SetNum(int num)
}
{this.num = num;}
+ this.num;}
, isLike (Object obj) ‫ בשם‬,‫ פעולה בוליאנית הניתנת לדריסה‬AA ‫הגדר במחלקה‬
‫ וגם תוכן‬AA ‫ הינו מטיפוס‬obj ‫ אם העצם‬. Object ‫ מטיפוס‬obj ‫המקבלת עצם‬
,true ‫ של העצם הנוכחי — הפעולה תחזיר‬st ‫ זהה לתוכן המחרוזת‬obj ‫ של‬st ‫המחרוזת‬
.false ‫אחרת — תחזיר‬
.‫א‬
.‫ פעולה הדורסת את הפעולה שהגדרת בסעיף א‬BB ‫הגדר במחלקה‬
num ‫ שלו זהה לערך התכונה‬num ‫ וגם ערך התכונה‬BB ‫ הינו מטיפוס‬obj ‫אם העצם‬
.false ‫ אחרת — תחזיר‬,true ‫של העצם הנוכחי — הפעולה תחזיר‬
.‫ב‬
/47 ‫המשך בעמוד‬/
‫ ‪- 47‬‬‫ג‪.‬‬
‫‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫לפניך קטע מפעולה ראשית‪:‬‬
‫;)"‪AA a = new AA("excellent‬‬
‫;)(‪BB b = new BB‬‬
‫;‪a = b‬‬
‫;)‪if (a.IsLike(b)) Console.WriteLine(a‬‬
‫‬
‫האם קטע התכנית תקין?‬
‫‬
‫אם כן — מה יהיה פלט הקטע? רשום איזו גרסה של הפעולה ‪ IsLike‬תופעל — זו של‬
‫‪ AA‬או זו של ‪.BB‬‬
‫‬
‫אם לא — הסבר מהי השגיאה ומתי היא תתגלה‪ :‬בזמן קומפילציה או בזמן ריצה‪.‬‬
‫‬
‫ד‪.‬‬
‫‬
‫לפניך קטע מפעולה ראשית‪:‬‬
‫;)(‪AA aa = new AA‬‬
‫;)"‪BB bb = new BB(2 , "excellent‬‬
‫;‪bb = aa‬‬
‫;)‪if (bb.IsLike(aa)) Console.WriteLine(bb‬‬
‫‬
‫האם קטע התכנית תקין?‬
‫‬
‫אם כן — מה יהיה פלט הקטע? רשום איזו גרסה של הפעולה ‪ IsLike‬תופעל — זו של‬
‫‬
‫‬
‫‪ AA‬או זו של ‪. BB‬‬
‫אם לא — הסבר מהי השגיאה ומתי היא תתגלה‪ :‬בזמן קומפילציה או בזמן ריצה‪.‬‬
‫ה‪.‬‬
‫כתוב פעולה חיצונית בשם ‪ LongString‬המקבלת מערך של עצמים מטיפוס ‪ . Object‬‬
‫‬
‫הפעולה מחזירה מחרוזת המורכבת משרשור התכונה ‪ st‬של עצמים מטיפוס ‪AA‬‬
‫‬
‫במערך‪ ,‬באופן הזה‪:‬‬
‫‬
‫‬
‫—‬
‫אם לעצם יש רק התכונה ‪ , st‬תשורשר המחרוזת שבתכונה ‪ st‬פעם אחת‪.‬‬
‫‬
‫—‬
‫אם לעצם יש גם התכונה ‪ , num‬המחרוזת שבתכונה ‪ st‬תשורשר ‪ num‬פעמים‪.‬‬
‫‬
‫—‬
‫אם אין במערך אף עצם מטיפוס ‪ , AA‬תוחזר מחרוזת ריקה‪.‬‬
‫‬
‫‪/‬המשך בעמוד ‪/48‬‬
‫‬
603 ,899205 '‫ מס‬,‫ קיץ תשע"א‬,'‫מדעי המחשב ב‬
- 48 :OopTest –‫ ו‬A , D , B ‫ לפניך פרויקט ובו המחלקות‬.22
public class B
{
private static int numB = 0;
private int m1;
private int m2;
public B(int m1, int m2)
{
}
}
this.m1 = m1;
this.m2 = m2;
numB++;
Console.WriteLine("B(" + m1 + ", " + m2 + ") , #" + numB);
public class D : B
{
private static int numD = 0;
private double d;
public D(double d, int x) : base (x , x)
{
}
this.d = d;
numD++;
Console.WriteLine("D(" + d + ", " + x + ") , #" + numD);
public D(double d, int x, int y) : base(x , y)
{
}
this.d = d;
numD++;
Console.WriteLine("D(" + d +", "+ x + " , " + y + ") , #" + numD);
}
/49 ‫המשך בעמוד‬/
603 ,899205 '‫ מס‬,‫ קיץ תשע"א‬,'‫מדעי המחשב ב‬
- 49 -
public class A
{
private static int numA = 0;
private B b;
private A a;
public A(A a , B b)
{
this.a = a;
numA++;
}
}
this.b = b;
Console.WriteLine("A Constructor , #" + numA);
public class OopTest
{
public static void Main(string[ ] args)
{
B w1 = new B(2 , 3);
B w3 = new D(2.3 , 8 , 9);
}
}
B w2 = new D(1.5 , 6);
A w4 = new A(null , w1);
A w5 = new A(w4 , w3);
.‫ וכתוב את הפלט‬, OopTest ‫ במחלקה‬Main ‫כתוב מעקב אחר הפעולה‬
.‫ ובעבור כל עצם — את ערכי התכונות שלו‬,‫במעקב יש לכתוב את ערכי המשתנים‬
/50 ‫המשך בעמוד‬/
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫‪- 50 -‬‬
‫‪ .23‬חברה המפיצה לומדות פיתחה לומדה העוסקת בסדרות של מספרים שלמים‪.‬‬
‫המערכת פותחה בשלבים‪.‬‬
‫‬
‫עבור כל סדרה של מספרים מתייחסים אל‪:‬‬
‫‬
‫(‪ )1‬האיבר הראשון בסדרה שמספרו הסידורי הוא ‪.1‬‬
‫‬
‫(‪ )2‬האיבר שמספרו הסידורי בסדרה הוא ‪. n‬‬
‫‬
‫(‪ )3‬הדפסת ‪ n‬האיברים הראשונים בסדרה‪.‬‬
‫‬
‫בשלב הראשון פותחו שתי המחלקות‪:‬‬
‫‬
‫סדרה חשבונית )‪ — (ASeq‬סדרה שבה ההפרש בין כל איבר לקודמו הוא ערך קבוע‪.‬‬
‫‬
‫סדרה הנדסית )‪ — (GSeq‬סדרה שבה המנה בין כל איבר לקודמו היא ערך קבוע‪.‬‬
‫‬
‫להלן קוד המחלקות שפותחו בשלב הראשון‪:‬‬
‫‪public class ASeq‬‬
‫{‬
‫;‪private int first‬‬
‫‬
‫;‪private int difference‬‬
‫‬
‫‬
‫)‪public ASeq(int first, int difference‬‬
‫‬
‫{‬
‫‬
‫;‪this.first = first‬‬
‫‬
‫;‪this.difference = difference‬‬
‫‬
‫}‬
‫‬
‫)‪public int TheNElement(int n‬‬
‫‬
‫{‬
‫‬
‫;‪return this.first + (n-1) * this.difference‬‬
‫‬
‫}‬
‫‬
‫‪/‬המשך בעמוד ‪/51‬‬
603 ,899205 '‫ מס‬,‫ קיץ תשע"א‬,'‫מדעי המחשב ב‬
- 51 -
public void DisplayNElements(int n)
{
Console.Write("The sequence elements: ");
for (int i = 0; i < n-1; i++)
}
}
Console.Write(this.TheNElement(i+1) + " , ");
Console.WriteLine(this.TheNElement(n));
public class Gseq
{
private int first;
public Gseq(int first, int product)
private int product;
{
}
this.first = first;
this.product = product;
public int TheNElement(int n)
{
}
{
return this.first * (int)Math.Pow(this.product , n-1);
public void DisplayNElements(int n)
Console.Write("The sequence elements: ");
}
}
for (int i = 0; i < n-1; i++)
Console.Write(this.TheNElement(i+1) + " , ");
Console.WriteLine (this.TheNElement(n));
/52 ‫המשך בעמוד‬/
).‫ המשך השאלה בעמוד בא‬:‫(שים לב‬
‫ ‪- 52‬‬‫א‪.‬‬
‫‬
‫‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫עקוב אחר קטע התכנית שלפניך‪ .‬במעקב הצג את העצם שנבנה‪ ,‬את התכונות שלו‬
‫‬
‫ואת הפלט‪.‬‬
‫;)‪ASeq aSeq = new ASeq(2 , 3‬‬
‫;))‪Console.WriteLine(aSeq.TheNElement(4‬‬
‫;)‪aSeq.DisplayNElements(5‬‬
‫‬
‫בשלב השני של הפיתוח הוחלט שמתאים לפתח מחלקה חדשה המתארת סדרה קבועה‬
‫)‪ ,(Sequence‬כך שהמחלקות ‪ ASeq‬ו– ‪ GSeq‬יירשו מן המחלקה החדשה‪ .‬בסדרה קבועה‬
‫‬
‫מוגדר ערך האיבר הראשון‪ ,‬וכל יתר האיברים זהים לאיבר הראשון‪.‬‬
‫‬
‫ב‪.‬‬
‫השלם את הפיתוח של השלב השני באופן המתאים ביותר לעקרונות של תכנות‬
‫‬
‫מונחה עצמים ובהתאם להנחיות )‪:(ii)-(i‬‬
‫)‪( i‬‬
‫‬
‫ממש באופן מלא את מחלקת העל ‪ .Sequence‬המחלקה צריכה להתייחס אל‪ :‬‬
‫‬
‫(‪)1‬‬
‫האיבר הראשון בסדרה שמספרו הסידורי ‪.1‬‬
‫‬
‫(‪)2‬‬
‫האיבר שמספרו הסידורי בסדרה הוא ‪. n‬‬
‫‬
‫(‪)3‬‬
‫הדפסת ‪ n‬האיברים הראשונים של הסדרה‪.‬‬
‫‬
‫)‪ (ii‬ממש מחדש את המחלקה ‪ ASeq‬כך שתירש מן המחלקה ‪. Sequence‬‬
‫‬
‫בשלב השלישי של הפיתוח הוחלט להרחיב את הפרויקט שכולל את שלוש המחלקות‬
‫שפותחו בשלב השני )‪ ,(Sequence , ASeq , GSeq‬כך שבעבור כל סדרה יהיה אפשר‬
‫להפעיל פעולה המחשבת ומחזירה את סכום ‪ n‬האיברים הראשונים של הסדרה‪.‬‬
‫הנח כי המחלקה ‪ GSeq‬מומשה מחדש כך שהיא יורשת מן המחלקה ‪. Sequence‬‬
‫‬
‫‬
‫ג‪.‬‬
‫בעבור כל אחת מן המחלקות ‪ , Sequence , ASeq , GSeq‬כתוב אם‬
‫‬
‫יש לעשות בה שינויים כך שהפרויקט יענה על דרישות הפיתוח של השלב השלישי‬
‫‬
‫באופן המתאים ביותר לעקרונות של תכנות מונחה עצמים‪.‬‬
‫‬
‫אם יש לעשות שינויים — פרט וממש אותם‪.‬‬
‫‬
‫‪/‬המשך בעמוד ‪/53‬‬
‫‪- 53 -‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫‬
‫‬
‫בשלב הרביעי של הפיתוח הוחלט לפתח פעולה סטטית ‪ Check‬המקבלת ערך שלם ‪, n‬‬
‫‬
‫ושני עצמים של סדרות‪ :‬האחד מטיפוס ‪ ASeq‬והאחר מטיפוס ‪. GSeq‬‬
‫הפעולה מחשבת את סכום ‪ n‬האיברים הראשונים בכל אחת משתי הסדרות ומחזירה‪:‬‬
‫—‬
‫את התו '‪ — 'A‬אם סכום ‪ n‬האיברים הראשונים של הסדרה מטיפוס ‪ ASeq‬הוא‬
‫‬
‫הגדול מבין שני הסכומים‪.‬‬
‫—‬
‫את התו '‪ — 'G‬אם סכום ‪ n‬האיברים הראשונים של הסדרה מטיפוס ‪ GSeq‬הוא‬
‫‬
‫הגדול מבין שני הסכומים‪.‬‬
‫‬
‫—‬
‫את התו '‪ — 'E‬אם סכום ‪ n‬האיברים הראשונים של שתי הסדרות שווה‪.‬‬
‫‬
‫ד‪.‬‬
‫ממש את הפעולה הסטטית ‪ Check‬על פי הדרישות שהוגדרו בשלב הרביעי‬
‫‬
‫של הפיתוח‪.‬‬
‫‬
‫‬
‫‪/‬המשך בעמוד ‪/54‬‬
‫‬
‫‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫‪- 54 -‬‬
‫‪ .24‬מרפאה וטרינרית של חיות מחמד מרכזת מידע על הווטרינרים העובדים במרפאה ועל‬
‫‬
‫חיות המחמד המטופלות בה‪ .‬מספר הווטרינרים העובדים במרפאה הוא לכל היותר ‪, 10‬‬
‫ומספר חיות המחמד המטופלות במרפאה הוא לכל היותר ‪. 500‬‬
‫הקווים המנחים לניהול המידע הם‪:‬‬
‫‬
‫• לכל וטרינר נשמר‪ :‬מספר תעודת הזהות‪ ,‬שם‪ ,‬ותק בעבודה בשנים‪.‬‬
‫‬
‫לכל חיית מחמד נשמר‪ :‬מספר הרישוי‪ ,‬שם‪ ,‬סוג (למשל‪ :‬כלב‪ ,‬חתול או ארנב)‪,‬‬
‫•‬
‫‬
‫גיל‪ ,‬פירוט של עד ‪ 50‬הביקורים האחרונים במרפאה‪ ,‬מספר הביקורים השמורים‪.‬‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫לכל ביקור במרפאה נשמר‪ :‬מספר תעודת הזהות של הווטרינר שטיפל בחיית המחמד‬
‫•‬
‫בביקור זה‪ ,‬ומחרוזת של תווים המכילה קודים של טיפולים שחיית המחמד קיבלה ‬
‫‬
‫באותו ביקור‪ .‬קוד של טיפול הוא אות גדולה מתוך כל אותיות ה– ‪. ABC‬‬
‫‬
‫חלק מהפעולות שהמערכת יכולה לבצע הן‪:‬‬
‫הפקת דוח של כל חיות המחמד מסוג מסוים (למשל כל הארנבים)‪ .‬לכל חיה‬
‫•‬
‫הדוח יכלול את מספר הרישוי שלה‪ ,‬את שמה ואת גילה‪.‬‬
‫‬
‫בתחילת כל שנה‪ :‬עדכון הגיל של כל חיית מחמד‪ ,‬כלומר הגדלת הגיל ב–‪,1‬‬
‫•‬
‫ועדכון הוותק של כל וטרינר‪ ,‬כלומר הגדלת הוותק ב–‪. 1‬‬
‫‬
‫החזרת שם של וטרינר על פי מספר תעודת הזהות שלו‪.‬‬
‫•‬
‫לפניך תרשים של היררכיית המחלקות הנדרשות בעבור ניהול המידע של המרפאה‪:‬‬
‫‪Clinic‬‬
‫‪˙‡ ˙‚ˆÈÈÓ‬‬
‫‪‰‡Ù¯Ó‰‬‬
‫‪Vet‬‬
‫‪¯ȯË ˙‚ˆÈÈÓ‬‬
‫‪ÔÓÈÒ‰‬‬
‫‪Animal‬‬
‫‪˙‚ˆÈÈÓ‬‬
‫‪„ÓÁÓ ˙ÈÈÁ‬‬
‫‪Appointment‬‬
‫‪¯Â˜È· ˙‚ˆÈÈÓ‬‬
‫‡ˆ‪¯ȯË Ï‬‬
‫·˙¯˘‪ƉÏΉ ‚ˆÈÈÓ ÌÈ‬‬
‫‪/‬המשך בעמוד ‪/55‬‬
‫ ‪- 55‬‬‫א‪.‬‬
‫‬
‫‬
‫‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"א‪ ,‬מס' ‪603 ,899205‬‬
‫בעבור כל מחלקה בתרשים‪ ,‬הגדר את התכונות ואת הפעולות שלה‪.‬‬
‫עליך להגדיר רק את הפעולות הנחוצות כדי לענות על הדרישות שתוארו בפתיח‬
‫‬
‫לשאלה (שבעמוד ‪ )54‬ובתרשים‪.‬‬
‫‬
‫הנח שנתונות פעולות בונות‪ ,‬המקבלות פרמטר לכל תכונה‪ ,‬ופעולות מאחזרות‬
‫‬
‫(פעולות ‪ ,)get‬ואין צורך לכתוב אותן‪ .‬לא נתונות פעולות קובעות (פעולות ‪. )set‬‬
‫‬
‫‬
‫בעבור כל תכונה — רשום את ההגדרה שלה ב– ‪ , C#‬ורשום את התיעוד שלה‪.‬‬
‫‬
‫בעבור כל פעולה — רשום את הכותרת שלה ב– ‪ , C#‬ורשום תיעוד הכולל‬
‫‬
‫מה היא מקבלת ומה היא מחזירה‪ .‬אין צורך לממש את הפעולה‪.‬‬
‫ב‪.‬‬
‫הנח כי המערכת פותחה בהתאם לתכנון שהצגת בסעיף א‪ ,‬וכל הפעולות הנתונות ‬
‫‬
‫ואלו שהגדרת ממומשות‪.‬‬
‫‬
‫‬
‫במחלקה ‪ Clinic‬מוסיפים את הפעולה‪:‬‬
‫‬
‫‬
‫‬
‫‬
‫המקבלת חיית מחמד ‪ , p‬מחרוזת ‪ t‬של קודים של טיפולים שקיבלה החיה בביקור ‬
‫הנוכחי ואת הווטרינר ‪ v‬שטיפל בה‪.‬‬
‫הפעולה מוסיפה את הביקור לחיית המחמד‪.‬‬
‫ממש באופן מלא את הפעולה‪.‬‬
‫‬
‫הנח שמספר הביקורים הקודמים של החיה במרפאה קטן מ–‪. 50‬‬
‫)‪public void AddAppointment (Animal p , string t , Vet v‬‬
‫‬
‫אם נוסף על הפעולות הנתונות ועל הפעולות שהגדרת בסעיף א אתה משתמש‬
‫‬
‫בפעולות אחרות‪ ,‬עליך לממש אותן באופן מלא ולציין בעבור כל פעולה באיזו‬
‫‬
‫מחלקה יש לממש אותה‪.‬‬
‫בהצלחה!‬
‫זכות היוצרים שמורה למדינת ישראל‬
‫אין להעתיק או לפרסם אלא ברשות משרד החינוך‬
‫‬