1. No category

‫מדינת ישרא ל‬
‫סוג הבחינה‪:‬‬
‫‬
‫מועד הבחינה‪:‬‬
‫מספר השאלון‪:‬‬
‫משרד החינוך‬
‫‬
‫‬
‫א‪ .‬בגרות לבתי ספר על־יסודיים‬
‫ב‪ .‬בגרות לנבחנים חיצוניים‬
‫קיץ תשע"ג‪2013 ,‬‬
‫‬
‫‪603 ,899205‬‬
‫מ ד ע י ה מ ח ש ב ב'‬
‫‪ 2‬יחידות לימוד (השלמה ל־‪ 5‬יח"ל)‬
‫הוראות לנבחן‬
‫א‪.‬‬
‫משך הבחינה‪ :‬שלוש שעות‪.‬‬
‫ב‪ .‬מבנה השאלון ומפתח ההערכה‪ :‬בשאלון זה שני פרקים‪.‬‬
‫פרק ראשון — בפרק זה ארבע שאלות‪,‬‬
‫‬
‫ומהן יש לענות על שתיים‪.‬‬
‫‬
‫‬
‫— בפרק זה שאלות בארבעה מסלולים שונים‪.‬‬
‫פרק שני‬
‫‬
‫ענה על שאלות רק במסלול שלמדת‪,‬‬
‫‬
‫לפי ההוראות בקבוצת השאלות במסלול זה‪.‬‬
‫‬
‫‬
‫ג‪.‬‬
‫— (‪ 50 — )25x2‬נקודות‬
‫— (‪ 50 — )25x2‬נקודות‬
‫— ‪ 100‬נקודות‬
‫סה"כ‬
‫חומר עזר מותר בשימוש‪ :‬כל חומר עזר‪ ,‬חוץ ממחשב הניתן לתכנות‪.‬‬
‫ד‪ .‬הוראות מיוחדות ‪:‬‬
‫(‪ )1‬את כל התכניות שאתה נדרש לכתוב בשפת מחשב בפרק הראשון‬
‫‬
‫כתוב בשפה אחת בלבד — ‪ C#‬או ‪. Java‬‬
‫‬
‫(‪ )2‬רשוֹ ם על הכריכה החיצונית של המחברת באיזו שפה אתה כותב — ‪ C#‬או ‪. Java‬‬
‫‬
‫(‪ )3‬רשוֹ ם על הכריכה החיצונית של המחברת את שם המסלול שלמדת‪,‬‬
‫‬
‫אחד מארבעת המסלולים‪ :‬מערכות מחשב ואסמבלר‪ ,‬מבוא לחקר ביצועים‪,‬‬
‫‬
‫מודלים חישוביים‪ ,‬תכנות מונחה עצמים‪.‬‬
‫‬
‫הערה‪ :‬בתכניות שאתה כותב לא יוּרד ּו לך נקודות‪ ,‬אם תכתוב אות גדולה במקום‬
‫‬
‫אות קטנה או להפך‪.‬‬
‫‬
‫‬
‫‬
‫כתוב במחברת הבחינה בלבד‪ ,‬בעמודים נפרדים‪ ,‬כל מה שברצונך לכתוב כטיוטה (ראשי פרקים‪ ,‬חישובים וכדומה)‪.‬‬
‫רשוֹ ם "טיוטה" בראש כל עמוד טיוטה‪ .‬רישום טיוטות כלשהן על דפים שמחוץ למחברת הבחינה עלול לגרום לפסילת הבחינה!‬
‫ההנחיות בשאלון זה מנוסחות בלשון זכר ומכוונות לנבחנות ולנבחנים כאחד‪.‬‬
‫בהצלחה!‬
‫‪/‬המשך מעבר לדף‪/‬‬
603 ,899205 '‫ מס‬,‫ קיץ תשע"ג‬,'‫מדעי המחשב ב‬
-2-
‫השא לות‬
.‫ פרק ראשון ופרק שני‬:‫בשאלון זה שני פרקים‬
.‫ לפי ההוראות בכל פרק‬,‫עליך לענות על שאלות משני הפרקים‬
)‫ נקודות‬50( ‫פרק ראשון‬
‫ בכל שאלה שנדרש בה מימוש אתה יכול להשתמש בפעולות של המחלקות‬:‫שים לב‬
‫ אם אתה‬.‫ בלי לממש אותן‬, Node<T> , List<T> , BinTreeNode<T>
.‫משתמש בפעולות נוספות עליך לממש אותן‬
.)‫ נקודות‬25 — ‫ (לכל שאלה‬4-1 ‫ענה על שתיים מהשאלות‬
,)3-2 ‫ (עמודים‬Java ‫ אחד ב־‬:‫ לשאלה זו שני נוסחים‬:‫שים לב‬
.‫ עבוד על פי השפה שלמדת‬.)5-4 ‫ (עמודים‬C# ‫ואחד ב־‬
.1
Java ‫לפותרים ב־‬
. sod3 , sod2 , sod1 ‫לפניך שלוש פעולות‬
public static boolean sod1(List<Integer> list1, List<Integer> list2)
{
Node<Integer> node1 = list1.getFirst();
Node<Integer> node2 = list2.getFirst();
for (int i = 1; i <= 4; i++)
{
if ((node1 == null) || (node2 == null))
return false;
if ((i == 1) || (i == 4))
if (node1.getInfo() != node2.getInfo())
return false;
node1 = node1.getNext();
}
return true;
}
public static boolean sod2(List<Integer> list1, List<Integer> list2)
{
Node<Integer> node1 = list1.getFirst();
Node<Integer> node2 = list2.getFirst();
while ((node1 != null) && (node2 != null))
{
if (node1.getInfo() != node2.getInfo())
return false;
node1 = node1.getNext();
node2 = node2.getNext();
}
}
return true;
/3 ‫המשך בעמוד‬/
603 ,899205 '‫ מס‬,‫ קיץ תשע"ג‬,'‫מדעי המחשב ב‬
-3-
public static boolean sod3(List<Integer> list1, List<Integer> list2)
{
Node<Integer> node1 = list1.getFirst();
while (node1 != null)
{
boolean found = false;
Node<Integer> node2 = list2.getFirst();
while ((node2 ! = null) && (!found))
{
if (node1.getInfo() == node2.getInfo())
found = true;
node2 = node2.getNext();
}
if (!found)
return false;
node1 = node1.getNext();
}
return true;
}
list2 ‫ ו־‬list1 ‫ עם הרשימות‬, sod3 , sod2 , sod1 ‫עקוב אחר כל אחת מהפעולות‬
.‫א‬
:‫שלפניך‬
list1: 2 " 4 " 5 " 1 " 1 " 9 ";z
list2: 2 " 4 " 5 " 1 " 4 ";z
.‫ במעקב הראה את המעבר על הרשימות‬.‫רשום מה יוחזר בעבור כל אחת מהפעולות‬
.‫ ? נמק את תשובתך‬sod3 , sod2 , sod1 ‫מהי סיבוכיות זמן הריצה של כל אחת מהפעולות‬
.‫ב‬
/4 ‫המשך בעמוד‬/
603 ,899205 '‫ מס‬,‫ קיץ תשע"ג‬,'‫מדעי המחשב ב‬
-4C# ‫לפותרים ב־‬
. Sod3 , Sod2 , Sod1 ‫לפניך שלוש פעולות‬
public static bool Sod1(List<int> list1, List<int> list2)
{
Node<int> node1 = list1.GetFirst();
for (int i = 1; i <= 4; i++)
Node<int> node2 = list2.GetFirst();
{
if ((node1 == null) || (node2 == null))
if ((i == 1) || (i == 4))
return false;
if (node1.GetInfo() != node2.GetInfo())
return false;
}
}
node1 = node1.GetNext();
return true;
public static bool Sod2(List<int> list1, List<int> list2)
{
Node<int> node1 = list1.GetFirst();
while ((node1 != null) && (node2 != null))
Node<int> node2 = list2.GetFirst();
{
if (node1.GetInfo() != node2.GetInfo())
node1 = node1.GetNext();
return false;
}
}
node2 = node2.GetNext();
return true;
/5 ‫המשך בעמוד‬/
603 ,899205 '‫ מס‬,‫ קיץ תשע"ג‬,'‫מדעי המחשב ב‬
-5-
public static bool Sod3(List<int> list1, List<int> list2)
{
Node<int> node1 = list1.GetFirst();
while (node1 != null)
{
bool found = false;
while ((node2 != null) && (!found))
Node<int> node2 = list2.GetFirst();
{
if (node1.GetInfo() == node2.GetInfo())
node2 = node2.GetNext();
}
found = true;
if (!found)
node1 = node1.GetNext();
}
}
return false;
return true;
:‫ שלפניך‬list2 ‫ ו־‬list1 ‫ עם הרשימות‬, Sod3 , Sod2 , Sod1 ‫עקוב אחר כל אחת מהפעולות‬
.‫א‬
list1: 2 " 4 " 5 " 1 " 1 " 9 ";z
list2: 2 " 4 " 5 " 1 " 4 ";z
.‫ במעקב הראה את המעבר על הרשימות‬.‫רשום מה יוחזר בעבור כל אחת מהפעולות‬
.‫ ? נמק את תשובתך‬Sod3 , Sod2 , Sod1 ‫מה סיבוכיות זמן הריצה של כל אחת מהפעולות‬
.‫ב‬
/6 ‫המשך בעמוד‬/
‫‪-6‬‬‫‪.2‬‬
‫‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫שים לב‪ :‬לשאלה זו שני נוסחים‪ :‬אחד ב־ ‪( Java‬עמוד ‪,)6‬‬
‫ואחד ב־ ‪( C#‬עמוד ‪ .)7‬עבוד על פי השפה שלמדת‪.‬‬
‫לפותרים ב־ ‪Java‬‬
‫עץ טרינארי הוא עץ שיש בו לכל היותר שלושה בנים לצומת‪ ,‬בן שמאלי‪ ,‬בן אמצעי ובן ימני‪.‬‬
‫לפניך ממשק חלקי של המחלקה "צומת טרינארי" >‪. TriTreeNode<T‬‬
‫המחלקה מגדירה צומת טרינארי שבו ערך מטיפוס ‪ T‬ושלוש הפניות לצמתים טרינאריים‪.‬‬
‫שם הפעולה‬
‫תיאור‬
‫הפעולה בונה צומת טרינארי שערכו יהיה ‪, x‬‬
‫וערך שלוש ההפניות יהיה ‪. null‬‬
‫הפעולה בונה צומת טרינארי שערכו יהיה ‪. x‬‬
‫‪ — left‬הפניה לבן שמאלי‪ — middle ,‬הפניה לבן‬
‫אמצעי‪ ,‬ו־ ‪ — right‬הפניה לבן ימני‪.‬‬
‫ערכי ההפניות יכולים להיות ‪. null‬‬
‫הפעולה מחזירה את הערך של הצומת הטרינארי‪.‬‬
‫הפעולה משנה את הערך השמור בצומת הטרינארי‬
‫ל־ ‪. x‬‬
‫הפעולה מחזירה את הבן השמאלי של הצומת‬
‫הטרינארי‪.‬‬
‫אם אין בן שמאלי‪ ,‬הפעולה מחזירה ‪. null‬‬
‫הפעולה מחזירה את הבן האמצעי של הצומת הטרינארי‪.‬‬
‫אם אין בן אמצעי‪ ,‬הפעולה מחזירה ‪. null‬‬
‫הפעולה מחזירה את הבן הימני של הצומת הטרינארי‪.‬‬
‫אם אין בן ימני‪ ,‬הפעולה מחזירה ‪. null‬‬
‫‬
‫א‪.‬‬
‫‬
‫ב‪.‬‬
‫)‪TriTreeNode( T x‬‬
‫‪(TriTreeNode<T> left,‬‬
‫‪TriTreeNode<T> middle,‬‬
‫)‪TriTreeNode<T> right, T x‬‬
‫‪TriTreeNode‬‬
‫)(‪T getInfo‬‬
‫)‪void setInfo(T x‬‬
‫)(‪TriTreeNode<T> getLeft‬‬
‫)(‪TriTreeNode<T> getMiddle‬‬
‫)(‪TriTreeNode<T> getRight‬‬
‫כתוב ב־ ‪ Java‬פעולה חיצונית ‪ big‬שתקבל עץ טרינארי ‪ t‬של מספרים שלמים וגדולים מ־ ‪ , 0‬‬
‫ותחזיר את המספר הגדול ביותר בעץ‪ .‬אם העץ ריק‪ ,‬הפעולה תחזיר ‪. -1‬‬
‫לפניך כותרת של פעולה‪:‬‬
‫)‪public static boolean noThree(TriTreeNode<Integer> tr‬‬
‫הפעולה מקבלת עץ טרינארי ‪ tr‬של מספרים שלמים ומחזירה ‪ true‬אם בכל אחד מהצמתים‬
‫‬
‫שבעץ יש לכל היותר שני בנים‪ .‬אחרת — הפעולה מחזירה ‪ . false‬אם העץ ריק‪ ,‬הפעולה‬
‫תחזיר ‪. true‬‬
‫‬
‫ממש את הפעולה ב־ ‪. Java‬‬
‫‬
‫הערה‪ :‬אתה יכול להשתמש בפעולות המחלקה ‪ TriTreeNode‬בלי לממש אותן‪.‬‬
‫אם אתה משתמש בפעולות נוספות‪ ,‬עליך לממש אותן‪.‬‬
‫‬
‫‪/‬המשך בעמוד ‪/7‬‬
‫‬
‫‪-7-‬‬
‫לפותרים ב־ ‪C#‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫עץ טרינארי הוא עץ שיש בו לכל היותר שלושה בנים לצומת‪ ,‬בן שמאלי‪ ,‬בן אמצעי ובן ימני‪.‬‬
‫לפניך ממשק חלקי של המחלקה "צומת טרינארי" >‪. TriTreeNode<T‬‬
‫המחלקה מגדירה צומת טרינארי שבו ערך מטיפוס ‪ T‬ושלוש הפניות לצמתים טרינאריים‪.‬‬
‫שם הפעולה‬
‫תיאור‬
‫הפעולה בונה צומת טרינארי שערכו יהיה ‪, x‬‬
‫וערך שלוש ההפניות יהיה ‪. null‬‬
‫הפעולה בונה צומת טרינארי שערכו יהיה ‪. x‬‬
‫‪ — left‬הפניה לבן שמאלי‪ — middle ,‬הפניה לבן‬
‫אמצעי‪ ,‬ו־ ‪ — right‬הפניה לבן ימני‪.‬‬
‫ערכי ההפניות יכולות להיות ‪. null‬‬
‫הפעולה מחזירה את הערך של הצומת הטרינארי‪.‬‬
‫הפעולה משנה את הערך השמור בצומת הטרינארי‬
‫ל־ ‪. x‬‬
‫הפעולה מחזירה את הבן השמאלי של הצומת‬
‫הטרינארי‪.‬‬
‫אם אין בן שמאלי‪ ,‬הפעולה מחזירה ‪. null‬‬
‫הפעולה מחזירה את הבן האמצעי של הצומת‬
‫הטרינארי‪.‬‬
‫אם אין בן אמצעי‪ ,‬הפעולה מחזירה ‪. null‬‬
‫הפעולה מחזירה את הבן הימני של הצומת הטרינארי‪.‬‬
‫אם אין בן ימני‪ ,‬הפעולה מחזירה ‪. null‬‬
‫‬
‫א‪.‬‬
‫‬
‫ב‪.‬‬
‫)‪TriTreeNode( T x‬‬
‫‪TriTreeNode‬‬
‫‪(TriTreeNode<T> left,‬‬
‫‪TriTreeNode<T> middle,‬‬
‫)‪TriTreeNode<T> right, T x‬‬
‫)(‪T GetInfo‬‬
‫)‪void SetInfo(T x‬‬
‫)(‪TriTreeNode<T> GetLeft‬‬
‫)(‪TriTreeNode<T> GetMiddle‬‬
‫)(‪TriTreeNode<T> GetRight‬‬
‫כתוב ב־ ‪ C#‬פעולה חיצונית ‪ Big‬שתקבל עץ טרינארי ‪ t‬של מספרים שלמים וגדולים מ־ ‪ , 0‬‬
‫ותחזיר את המספר הגדול ביותר בעץ‪ .‬אם העץ ריק‪ ,‬הפעולה תחזיר ‪. -1‬‬
‫לפניך כותרת של פעולה‪:‬‬
‫)‪public static bool NoThree(TriTreeNode<int> tr‬‬
‫הפעולה מקבלת עץ טרינארי ‪ tr‬של מספרים שלמים ומחזירה ‪ , true‬אם בכל אחד‬
‫‬
‫מהצמתים שבעץ יש לכל היותר שני בנים‪ .‬אחרת — הפעולה מחזירה ‪ . false‬אם העץ ריק‪,‬‬
‫הפעולה תחזיר ‪. true‬‬
‫ממש את הפעולה ב־ ‪. C#‬‬
‫‬
‫הערה‪ :‬אתה יכול להשתמש בפעולות המחלקה ‪ TriTreeNode‬בלי לממש אותן‪.‬‬
‫אם אתה משתמש בפעולות נוספות‪ ,‬עליך לממש אותן‪.‬‬
‫‬
‫‪/‬המשך בעמוד ‪/8‬‬
‫‪-8‬‬‫‪.3‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫בשאלה זו שני סעיפים‪ ,‬א‪-‬ב‪ ,‬שאין קשר ביניהם‪ .‬ענה על שניהם‪.‬‬
‫א‪.‬‬
‫לאבן משחק יש שני צדדים‪ .‬על צד אחד רשוּם אחד מהמספרים החד־ספרתיים בין ‪ 0‬ל־ ‪6‬‬
‫(כולל)‪ ,‬ועל הצד האחר רשום אחד מהמספרים הדו־ספרתיים בין ‪ 10‬ל־ ‪( 16‬כולל)‪.‬‬
‫(‪ )1‬כתוֹ ב ב־ ‪ Java‬או ב־ ‪ C#‬את כותרת המחלקה ‪ , BiStone‬המגדירה אבן משחק‪,‬‬
‫ואת התכונות שלה‪.‬‬
‫(‪ )2‬כתוב ב־ ‪ Java‬או ב־ ‪ C#‬במחלקה ‪ , BiStone‬פעולה בונה המקבלת שני מספרים‪,‬‬
‫האחד חד־ספרתי בין ‪ 0‬ל־ ‪ , 6‬והאחר דו־ספרתי בין ‪ 10‬ל־ ‪. 16‬‬
‫(‪ )3‬כתוב ב־ ‪ Java‬או ב־ ‪ C#‬במחלקה ‪ , BiStone‬פעולה פנימית שתחזיר ‪ , true‬אם‬
‫המספר החד־ספרתי שבצד האחד של אבן המשחק שווה לספרת האחדות של המספר‬
‫הדו־ספרתי שמופיע בצד השני של האבן‪ ,‬אחרת — הפעולה תחזיר ‪. false‬‬
‫המחלקה ‪ Stones‬היא אוסף של כל אבני ‪ BiStone‬האפשריות‪ .‬במחלקה אין שתי‬
‫אבנים שעליהן אותו צירוף של מספרים‪ .‬בסך הכול יש במחלקה ‪ 49 Stones‬אבני‬
‫‪. BiStone‬‬
‫(‪ )4‬כתוב ב־ ‪ Java‬או ב־ ‪ C#‬את כותרת המחלקה ‪ Stones‬ואת התכונות שלה‪.‬‬
‫(‪)5‬‬
‫כתוב ב־ ‪ Java‬או ב־ ‪ C#‬במחלקה ‪ , Stones‬פעולה בונה שתיצור את כל ‪49‬‬
‫אבני ה־ ‪. BiStone‬‬
‫(אין קשר לסעיף א‪).‬‬
‫ב‪.‬‬
‫(‪ )1‬כתוב ב־ ‪ Java‬או ב־ ‪ C#‬פעולה שתקבל מספר שלם ‪ , num‬גדול מ־ ‪, 1‬‬
‫‬
‫ורשימה ‪ lst‬המכילה מספרים שלמים גדולים מ־ ‪ , 0‬שכולם קטנים מ־ ‪. num‬‬
‫‬
‫הפעולה תחזיר רשימה חדשה שאיבריה הם כל המספרים השלמים הגדולים מ־ ‪0‬‬
‫‬
‫וקטנים מ־ ‪ , num‬שאינם מופיעים ברשימה ‪. lst‬‬
‫(‪ )2‬מהי סיבוכיות זמן הריצה של הפעולה שכתבת? נמק את תשובתך‪.‬‬
‫‪/‬המשך בעמוד ‪/9‬‬
‫‪-9‬‬‫‪.4‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫שים לב‪ :‬לשאלה זו שני נוסחים‪ :‬אחד ב־ ‪( Java‬עמודים ‪ ,)10-9‬ואחד ב־ ‪C#‬‬
‫(עמודים ‪ .)12-11‬עבוד על פי השפה שלמדת‪.‬‬
‫‬
‫לפותרים ב־ ‪Java‬‬
‫‬
‫בשאלה זו שני סעיפים‪ ,‬א‪-‬ב‪ ,‬שאין קשר ביניהם‪ .‬ענה על שניהם‪.‬‬
‫‬
‫א‪.‬‬
‫לפניך הפעולה ‪. amir‬‬
‫)‪public static void amir(BinTreeNode<Integer> t, int x‬‬
‫)‪if (t != null‬‬
‫;)‪amir(t.getLeft() , x + 1‬‬
‫))‪if ((t.getLeft() == null) && (t.getRight() == null‬‬
‫; )‪t.setInfo(x‬‬
‫{‬
‫‬
‫{‬
‫‬
‫‬
‫‬
‫;)‪amir(t.getRight() , x + 1‬‬
‫‬
‫}‬
‫}‬
‫לפניך העץ ‪. tree‬‬
‫‪tree‬‬
‫‪5‬‬
‫‪7‬‬
‫‪3‬‬
‫‪6‬‬
‫‪4‬‬
‫‪i‬‬
‫רשוֹ ם את העץ ‪ tree‬שיתקבל לאחר הפעלת הזימון‪. amir(tree , 4) :‬‬
‫‪i i‬‬
‫מה מבצעת הפעולה ‪ amir‬בעבור עץ כלשהו ו־ ‪? x = 0‬‬
‫(שים לב‪ :‬סעיף ב בעמוד הבא‪).‬‬
‫‪/‬המשך בעמוד ‪/10‬‬
‫ ‪- 10‬‬‫ב‪.‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫(אין קשר לסעיף א‪).‬‬
‫נתון עץ חיפוש בינארי ‪ , t‬המכיל לפחות שלושה צמתים שערכיהם‪. z , y , x :‬‬
‫לפניך שתי טענות‪:‬‬
‫(‪ ) 1‬אם ‪ y , x‬ו־ ‪ z‬הם ערכי שלושה צמתים עוקבים בסריקה תוכית (‪)inorder‬‬
‫של ‪ , t‬אז ‪. z = x‬‬
‫‬
‫(‪ )2‬אם ‪ x‬ו־ ‪ y‬הם ערכים של שני עלים ב־ ‪( t‬משמאל לימין)‪ ,‬אז ‪. x 2 y‬‬
‫לכל אחת מהטענות (‪ )2(-)1‬בחר באפשרות המתאימה מבין שלוש האפשרויות שלפניך‪:‬‬
‫•‬
‫הטענה תמיד נכונה‪ .‬נמק את תשובתך‪.‬‬
‫•‬
‫הטענה תמיד אינה נכונה‪ .‬נמק את תשובתך‪.‬‬
‫•‬
‫הטענה נכונה בחלק מהמקרים‪ .‬הבא דוגמה למקרה שבו הטענה נכונה‪ ,‬ודוגמה‬
‫‬
‫למקרה שבו הטענה אינה נכונה‪.‬‬
‫‪/‬המשך בעמוד ‪/11‬‬
‫‬
‫‪- 11 -‬‬
‫לפותרים ב־ ‪C#‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫בשאלה זו שני סעיפים‪ ,‬א‪-‬ב‪ ,‬שאין קשר ביניהם‪ .‬ענה על שניהם‪.‬‬
‫‬
‫א‪.‬‬
‫לפניך הפעולה ‪. Amir‬‬
‫)‪public static void Amir(BinTreeNode<int> t, int x‬‬
‫{‬
‫‬
‫)‪if (t != null‬‬
‫{‬
‫‬
‫; )‪Amir(t.GetLeft () , x + 1‬‬
‫))‪ if ((t.GetLeft() == null) && (t.GetRight() == null‬‬
‫‬
‫; )‪t.SetInfo (x‬‬
‫; )‪Amir(t.GetRight () , x + 1‬‬
‫לפניך העץ ‪. tree‬‬
‫‬
‫}‬
‫}‬
‫‪tree‬‬
‫‪5‬‬
‫‪7‬‬
‫‪3‬‬
‫‪6‬‬
‫‪4‬‬
‫‪i‬‬
‫רשום את העץ ‪ tree‬שיתקבל לאחר הפעלת הזימון‪. Amir(tree , 4) :‬‬
‫‪i i‬‬
‫מה מבצעת הפעולה ‪ Amir‬בעבור עץ כלשהו ו־ ‪? x = 0‬‬
‫(שים לב‪ :‬סעיף ב בעמוד הבא‪).‬‬
‫‪/‬המשך בעמוד ‪/12‬‬
‫ ‪- 12‬‬‫ב‪.‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫(אין קשר לסעיף א‪).‬‬
‫נתון עץ חיפוש בינארי ‪ , t‬המכיל לפחות שלושה צמתים שערכיהם‪. z , y , x :‬‬
‫לפניך שתי טענות‪:‬‬
‫(‪ )1‬אם ‪ y , x‬ו־ ‪ z‬הם ערכי שלושה צמתים עוקבים בסריקה תוכית (‪)inorder‬‬
‫‬
‫של ‪ , t‬אז ‪. z = x‬‬
‫(‪ )2‬אם ‪ x‬ו־ ‪ y‬הם ערכים של שני עלים ב־ ‪( t‬משמאל לימין)‪ ,‬אז ‪. x 2 y‬‬
‫לכל אחת מהטענות (‪ )2(-)1‬בחר באפשרות המתאימה מבין שלוש האפשרויות שלפניך‪:‬‬
‫•‬
‫הטענה תמיד נכונה‪ .‬נמק את תשובתך‪.‬‬
‫•‬
‫הטענה תמיד אינה נכונה‪ .‬נמק את תשובתך‪.‬‬
‫•‬
‫הטענה נכונה בחלק מהמקרים‪ .‬הבא דוגמה למקרה שבו הטענה נכונה‪ ,‬ודוגמה‬
‫‬
‫למקרה שבו הטענה אינה נכונה‪.‬‬
‫‪/‬המשך בעמוד ‪/13‬‬
‫‪- 13 -‬‬
‫פרק שני‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫(‪ 50‬נקודות)‬
‫בפרק זה שאלות בארבעה מסלולים‪:‬‬
‫מערכות מחשב ואסמבלר‪ ,‬עמ' ‪.17-13‬‬
‫‬
‫מבוא לחקר ביצועים‪ ,‬עמ' ‪.24-18‬‬
‫‬
‫מודלים חישוביים‪ ,‬עמ' ‪.29-25‬‬
‫‬
‫תכנות מונחה עצמים ב־ ‪ , Java‬עמ' ‪ ; 36-30‬תכנות מונחה עצמים ב־ ‪ , C#‬עמ' ‪.43-37‬‬
‫‬
‫ענה רק על שאלות במסלול שלמדת‪.‬‬
‫מערכות מחשב ואסמבלר‬
‫אם למדת מסלול זה‪ ,‬ענה על שתיים מהשאלות ‪( 8-5‬לכל שאלה — ‪ 25‬נקודות)‪.‬‬
‫‪.5‬‬
‫במקטע הנתונים הוגדרו הנתונים בצורה זו‪:‬‬
‫‬
‫לפניך קטע תכנית באסמבלר‪.‬‬
‫א‪.‬‬
‫‬
‫‬
‫‬
‫ב‪.‬‬
‫‪ NIBBLE DB1001B‬‬
‫‪ M DW0F000H‬‬
‫‪ NUMBER DW0E539H‬‬
‫‬
‫‪MOV CX , 4‬‬
‫‬
‫‪XOR DX , DX‬‬
‫‬
‫‪MOV DH , NIBBLE‬‬
‫‬
‫‪SHL DH , CL‬‬
‫‬
‫‪MOV CX , 13‬‬
‫‬
‫‪MOV AX , NUMBER‬‬
‫‪AGAIN: MOV BX , M‬‬
‫‬
‫‪AND BX , AX‬‬
‫‬
‫‪XOR BX , DX‬‬
‫‪ JZOK‬‬
‫‬
‫‪SHL AX , 1‬‬
‫‬
‫‪LOOPAGAIN‬‬
‫‪ JMPSOF‬‬
‫‪OK:‬‬
‫‪MOV CH , 1‬‬
‫‪SOF:NOP‬‬
‫עקוב בעזרת טבלת מעקב אחר הביצוע של קטע התכנית‪.‬‬
‫בטבלת המעקב ּ ָפ ֵרט בכל שלב את התוכן של ‪. DX , CX , BX , AX‬‬
‫מה מבצע קטע התכנית?‬
‫‪/‬המשך בעמוד ‪/14‬‬
‫ ‪- 14‬‬‫‬
‫‪. 6‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫בשאלה זו שני סעיפים‪ ,‬א‪-‬ב‪ ,‬שאין קשר ביניהם‪ .‬ענה על שניהם‪.‬‬
‫א‪.‬‬
‫‬
‫‬
‫במקטע הנתונים הוגדר המשתנה ‪ K‬בצורה זו‪:‬‬
‫לפניך קטע תכנית באסמבלר‪.‬‬
‫‪K‬‬
‫‬
‫‪DB5EH‬‬
‫‪MOV CX , 2‬‬
‫‬
‫‪MOV AL , AH‬‬
‫‬
‫‪MOV AH , K‬‬
‫‪SHL AX , CL‬‬
‫‪DECCL‬‬
‫‪SHR AH , CL‬‬
‫‪ADD AH , AL‬‬
‫‪SUB AH , CL‬‬
‫‪LOOPNEXT‬‬
‫‬
‫‬
‫‬
‫‪NEXT:‬‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫עקוב בעזרת טבלת מעקב אחר ביצוע קטע התכנית‪.‬‬
‫בטבלת המעקב ּ ָפ ֵרט בכל שלב את התוכן של‪. AL , AH , CL :‬‬
‫‪/‬המשך בעמוד ‪/15‬‬
‫ ‪- 15‬‬‫ב‪.‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫(אין קשר לסעיף א‪).‬‬
‫לפניך ‪ 4‬קטעי תכנית באסמבלר‪ . iv-i ,‬לאחר ביצוע כל אחד מהקטעים‪ ,‬על האוגר ‪AX‬‬
‫להכיל את אותו ערך שהכיל לפני ביצוע הקטע‪.‬‬
‫בעבור כל אחד מהקטעים ‪ iv-i‬שלפניך‪ ,‬קבע אם הוא מבצע את הנדרש או אינו מבצע את‬
‫הנדרש‪ .‬אם הקטע אינו מבצע את הנדרש‪ ,‬הבא דוגמה המראה זאת‪.‬‬
‫‪CL , 4‬‬
‫‪AX , CL‬‬
‫‪MOV‬‬
‫‪ROL‬‬
‫‪i‬‬
‫‬
‫‪CX , 4‬‬
‫‪BX , BX‬‬
‫‪BX , AX‬‬
‫‪AX , CL‬‬
‫‪BX , CL‬‬
‫‪AX , BX‬‬
‫‪MOV‬‬
‫‪XOR‬‬
‫‪MOV‬‬
‫‪SHR‬‬
‫‪SHL‬‬
‫‪MOV‬‬
‫‪ii‬‬
‫‬
‫‬
‫‬
‫‬
‫‬
‫‪AX‬‬
‫‪BX‬‬
‫‪BX , CL‬‬
‫‪AX , BX‬‬
‫‪PUSH‬‬
‫‬
‫‪POP‬‬
‫‬
‫‪ROR‬‬
‫‬
‫‪MOV‬‬
‫‬
‫‪CX , 4‬‬
‫‪BX , BX‬‬
‫‪iii MOV‬‬
‫‬
‫‪XOR‬‬
‫‪CX , 4‬‬
‫‪AX , CL‬‬
‫‪iv MOV‬‬
‫‬
‫‪ROL‬‬
‫‪BX , AX‬‬
‫‪BX , CL‬‬
‫‪BX , CL‬‬
‫‪AX , BX‬‬
‫‪AX‬‬
‫‪DX‬‬
‫‪DX , CL‬‬
‫‪AX , DX‬‬
‫‪ADD‬‬
‫‪SHL‬‬
‫‪SHR‬‬
‫‪MOV‬‬
‫‬
‫‬
‫‬
‫‬
‫‪PUSH‬‬
‫‬
‫‪POP‬‬
‫‬
‫‪ROR‬‬
‫‬
‫‪MOV‬‬
‫‪/‬המשך בעמוד ‪/16‬‬
‫ ‪- 16‬‬‫‪.7‬‬
‫‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫בשאלה זו שני סעיפים‪ ,‬א‪-‬ב‪ ,‬שאין קשר ביניהם‪ .‬ענה על שניהם‪.‬‬
‫א‪.‬‬
‫‬
‫לפניך קטע תכנית הכתוב ב־ ‪ Java‬וב־ ‪. C#‬‬
‫))‪while ((a<b) || (a > 0‬‬
‫};‪{a = a-1‬‬
‫המשתנים ‪ a‬ו־ ‪ b‬הם משתנים מטיפוס שלם‪.‬‬
‫‬
‫כתוב קטע תכנית באסמבלר שיבצע את קטע התכנית שלפניך‪.‬‬
‫‬
‫הנח שהמשתנה ‪ a‬מאוחסן באוגר ‪ , AX‬והמשתנה ‪ b‬מאוחסן באוגר ‪. BX‬‬
‫ב‪.‬‬
‫(אין קשר לסעיף א‪).‬‬
‫(‪ ) 1‬רשום הוראה אחת שתאפס את שני הביטים הראשונים ואת שני הביטים האחרונים‬
‫של האוגר ‪ , AL‬מבלי לשנות את הערכים של הביטים האחרים באוגר‪.‬‬
‫(‪ ) 2‬רשום הוראה אחת שתדליק (תהפוך ל־ ‪ )1‬את שני הביטים הראשונים ואת‬
‫שני הביטים האחרונים של האוגר ‪ , AL‬מבלי לשנות את הערכים של הביטים האחרים‬
‫באוגר‪.‬‬
‫(‪ ) 3‬רשום הוראה אחת שתגרום שארבעת הביטים הנמוכים של האוגר ‪ AL‬יהיו ‪, 1‬‬
‫‬
‫מבלי לשנות את הערכים של ארבעת הביטים הגבוהים של האוגר ‪. AL‬‬
‫(‪ ) 4‬במקטע הנתונים הוגדר המערך ‪ A‬בצורה זו‪:‬‬
‫‬
‫—‬
‫‬
‫‬
‫‬
‫—‬
‫)?( ‪A DW 20 DUP‬‬
‫רשום הוראה אחת שתכניס לאוגר ‪ AX‬את התוכן של האיבר החמישי‬
‫של המערך ‪. A‬‬
‫רשום הוראה אחת שתכניס לאוגר ‪ AX‬את הכתובת של האיבר החמישי של‬
‫המערך ‪. A‬‬
‫‪/‬המשך בעמוד ‪/17‬‬
‫‪- 17 -‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫‪.8‬‬
‫במקטע הנתונים הוגדרו הנתונים האלה‪:‬‬
‫‬
‫כתוֹ ב באסמבלר קטע תכנית שיציב במשתנה ‪ MIN‬את הערך הקטן ביותר המאוחסן‬
‫)?( ‪ARR DW 100 DUP‬‬
‫?‪MIN DW‬‬
‫‪NUM DW0‬‬
‫במערך ‪ . ARR‬קטע התכנית יציב במשתנה ‪ NUM‬את מספר הפעמים שהערך‪ ,‬שנמצא‬
‫במשתנה ‪ , MIN‬הופיע במערך‪.‬‬
‫על קטע התכנית לעבור פעם אחת בלבד על כל האיברים של המערך ‪.ARR‬‬
‫עליך להתייחס לכל המספרים כמספרים לא מסומנים‪.‬‬
‫‪/‬המשך בעמוד ‪/18‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫‪- 18 -‬‬
‫מבוא לחקר ביצועים‬
‫אם למדת מסלול זה‪ ,‬ענה על שתיים מהשאלות ‪( 12-9‬לכל שאלה — ‪ 25‬נקודות)‪.‬‬
‫‪ .9‬נתונה בעיית תכנון לינארי‪:‬‬
‫‬
‫בכפוף לאילוצים האלה‪:‬‬
‫‬
‫‬
‫}‪max {z = kx1 + 6x2‬‬
‫‪2x1 + 3x2 # 6‬‬
‫‪5x1 + 2x2 #10‬‬
‫‬
‫‪x1 $ 0‬‬
‫‬
‫‪ x2‬אינו מוגבל בסימן‪.‬‬
‫‪ k‬הוא פרמטר‪.‬‬
‫לפניך סרטוט של תחום הפתרונות האפשריים של הבעיה הנתונה‪.‬‬
‫‪x2‬‬
‫‪C‬‬
‫‪6‬‬
‫‪4‬‬
‫‪A‬‬
‫‪10‬‬
‫‪x1‬‬
‫‪6‬‬
‫‪18‬‬
‫) ‪E (11 , 11‬‬
‫‪D B‬‬
‫‪2‬‬
‫‪4‬‬
‫‪2‬‬
‫‪0 G‬‬
‫‪0‬‬
‫‪-2‬‬
‫‪-4‬‬
‫‪-2‬‬
‫‪H‬‬
‫‪F‬‬
‫‪/‬המשך בעמוד ‪/19‬‬
‫ ‪- 19‬‬‫‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫א‪.‬‬
‫לפניך חמישה תת־סעיפים (‪ )5(-)1‬שאינם תלויים זה בזה‪ .‬בחלק מהם נתון ערך מסוים‬
‫‬
‫של הפרמטר ‪. k‬‬
‫‬
‫בעבור כל אחד מהתת־סעיפים (‪:)5(-)1‬‬
‫‬
‫•‬
‫‬
‫אם הפתרון האופטימלי הוא יחיד‪ ,‬מצא את הפתרון האופטימלי היחיד‪ ,‬ואת הערך‬
‫של פונקציית המטרה בפתרון זה‪.‬‬
‫‬
‫•‬
‫אם הפתרון האופטימלי אינו חסום‪ ,‬נמק את קביעתך‪.‬‬
‫‬
‫•‬
‫אם אין פתרון אפשרי‪ ,‬נמק את קביעתך‪.‬‬
‫‬
‫(‪. k = 0 )1‬‬
‫‬
‫‬
‫‬
‫(‪. k = 6 )2‬‬
‫‬
‫(‪ )3‬משנים רק את פונקציית המטרה של הבעיה הנתונה בתחילת השאלה ל‪:‬‬
‫‬
‫‬
‫}‪. min {z = 6x2‬‬
‫(‪ ) 4‬משנים רק את פונקציית המטרה של הבעיה הנתונה בתחילת השאלה ל‪:‬‬
‫‬
‫‬
‫}‪. min {z = 6x1 + 6x2‬‬
‫(‪ )5‬משנים רק את פונקציית המטרה של הבעיה הנתונה בתחילת השאלה ל‪:‬‬
‫‬
‫}‪ , min {z = 6x1 + 6x2‬ומוסיפים את האילוץ ‪. x2 $ 0‬‬
‫ב‪.‬‬
‫בעבור אילו ערכים של ‪ k‬יהיו לבעיית התכנון הלינארי הנתונה בתחילת השאלה‬
‫‬
‫אין־סוף פתרונות אופטימליים?‬
‫‬
‫‬
‫‬
‫‬
‫קבע את הערך של פונקציית המטרה בעבור כל אחד מערכי ה־ ‪ k‬האלה‪ .‬נמק את קביעתך‪.‬‬
‫‪/‬המשך בעמוד ‪/20‬‬
‫‪- 20 -‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫‪ .10‬בשאלה זו שני סעיפים‪ ,‬א‪-‬ב‪ ,‬שאין קשר ביניהם‪ .‬ענה על שניהם‪.‬‬
‫א‪ .‬יהי )‪ G = (V , E‬גרף לא מכוון המיוצג על ידי מטריצת הסמיכויות שלפניך‪:‬‬
‫‪V‬‬
‫‪W‬‬
‫‪W‬‬
‫‪W‬‬
‫‪W‬‬
‫‪W‬‬
‫‪W‬‬
‫‪W‬‬
‫‪X‬‬
‫‪e‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪d‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪c‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪b‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪a‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪R‬‬
‫‪S‬‬
‫‪S‬‬
‫‪S‬‬
‫‪S‬‬
‫‪S‬‬
‫‪S‬‬
‫‪S‬‬
‫‪T‬‬
‫‪a‬‬
‫‪b‬‬
‫‪c‬‬
‫‪d‬‬
‫‪e‬‬
‫(‪ )1‬סרטט את הגרף ‪ G‬המיוצג על ידי המטריצה‪.‬‬
‫‬
‫(‪ )2‬כמה רכיבי קשירות (‪ )Connected Components‬יש בגרף הנתון‪ ,‬ומה הם?‬
‫‬
‫(‪ )3‬הסר קשת אחת מהגרף ‪ G‬שסרטטת‪ ,‬כך שמספר רכיבי הקשירות לא ישתנה‪.‬‬
‫‬
‫ציין את הקשת שהסרת‪.‬‬
‫‬
‫(‪ )4‬קשת בגרף תיקרא "קשת מפרידה" אם הסרתה מהגרף תגדיל את מספר רכיבי‬
‫‬
‫הקשירות ב־‪.1‬‬
‫‬
‫ציין "קשת מפרידה" אחת בגרף ‪. G‬‬
‫‬
‫סרטט את הגרף שמתקבל לאחר הסרת הקשת שציינת‪.‬‬
‫‬
‫ב‪( .‬אין קשר לסעיף א‪).‬‬
‫יהי )‪ G = (V , E‬גרף לא מכוון המיוצג על ידי רשימת הסמיכויות שלפניך‪:‬‬
‫‬
‫<" ‪a " b" c " g " e‬‬
‫<" ‪b " a" e " c‬‬
‫<" ‪c " a" b " f‬‬
‫<" ‪d " e‬‬
‫<" ‪e " a" b " d‬‬
‫<" ‪f " c" g‬‬
‫<" ‪g " a" f‬‬
‫(‪ ) 1‬הפעל אלגוריתם סריקה לעומק )‪ (DFS‬על הגרף הנתון‪ ,‬החל מקדקוד ‪. a‬‬
‫‬
‫סרטט במחברתך רק את העץ הפורש )‪ / (DFS‬היער הפורש )‪ (DFS‬שמתקבל‪.‬‬
‫‬
‫התבסס על הייצוג הנתון על ידי רשימת הסמיכויות‪.‬‬
‫‬
‫(‪ )2‬הפעל אלגוריתם סריקה לרוחב )‪ (BFS‬על הגרף הנתון‪ ,‬החל מקדקוד ‪ . a‬‬
‫‬
‫סרטט במחברתך רק את העץ הפורש )‪ / (BFS‬היער הפורש )‪ (BFS‬שמתקבל‪.‬‬
‫‬
‫התבסס על הייצוג הנתון על ידי רשימת הסמיכויות‪.‬‬
‫‬
‫‪/‬המשך בעמוד ‪/21‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫ ‪- 21‬‬‫‪ .11‬בשאלה זו שני סעיפים‪ ,‬א‪-‬ב‪ ,‬שאין קשר ביניהם‪ .‬ענה על שניהם‪.‬‬
‫א‪.‬‬
‫לפניך רשת‪:‬‬
‫‬
‫‪5‬‬
‫‪E‬‬
‫‪4‬‬
‫‪10‬‬
‫‪H‬‬
‫‪7‬‬
‫‪F‬‬
‫‬
‫‬
‫‪2‬‬
‫‪6‬‬
‫‪8‬‬
‫‪4‬‬
‫‪C‬‬
‫‪6‬‬
‫‪2‬‬
‫‪G‬‬
‫‬
‫‪20‬‬
‫‪B‬‬
‫‪16‬‬
‫‪A‬‬
‫‪8‬‬
‫‪D‬‬
‫מצא את המסלולים הקצרים ברשת הנתונה לפי האלגוריתם של דיקסטרה‪ ,‬מקדקוד ‪A‬‬
‫לכל קדקוד אחר ברשת‪ ,‬וצייר את התיאור הסכמתי של עץ המסלולים הקצרים‪.‬‬
‫בעבור כל קדקוד ברשת‪ ,‬רשום את אורך המסלול הקצר ביותר מקדקוד ‪ A‬עד אליו‪.‬‬
‫ב‪.‬‬
‫(אין קשר לסעיף א‪).‬‬
‫‬
‫לפניך רשת‪:‬‬
‫‬
‫‪8‬‬
‫‪C‬‬
‫‪B‬‬
‫‪5‬‬
‫‪A‬‬
‫‪10‬‬
‫‪1‬‬
‫‪D‬‬
‫(‪)1‬‬
‫‬
‫‬
‫לכל קדקוד אחר ברשת‪ ,‬וצייר את התיאור הסכמתי של עץ המסלולים הקצרים‪.‬‬
‫בעבור כל קדקוד ברשת‪ ,‬רשום את אורך המסלול הקצר ביותר מקדקוד ‪ A‬עד אליו‪.‬‬
‫‬
‫‬
‫מצא את המסלולים הקצרים ברשת הנתונה לפי האלגוריתם של דיקסטרה‪ ,‬מקדקוד ‪A‬‬
‫(‪ )2‬מוסיפים קשת לא מכוונת )‪ (A , D‬לרשת הנתונה‪.‬‬
‫‬
‫מה צריך להיות משקלה של הקשת‪ ,‬כדי שהמסלולים הקצרים מקדקוד ‪ A‬לכל אחד‬
‫‬
‫מהקדקודים האחרים לא ישתנו?‬
‫‪/‬המשך בעמוד ‪/22‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫ ‪- 22‬‬‫‪ .12‬בשאלה זו חמישה סעיפים‪ ,‬א‪-‬ה‪ ,‬שאין קשר ביניהם‪ .‬ענה על כל הסעיפים‪.‬‬
‫א‪ .‬בטבלה שלפניך נתון חלק מפתרון בסיסי אפשרי לבעיית התובלה‪. x11 = 5 :‬‬
‫יעדים‬
‫היצע‬
‫‪4‬‬
‫‪15‬‬
‫‪2‬‬
‫‪3‬‬
‫מקורות‬
‫‪1‬‬
‫‪10‬‬
‫‪11‬‬
‫‪20‬‬
‫‪10‬‬
‫‪20‬‬
‫‪19‬‬
‫‪7‬‬
‫‪12‬‬
‫‪18‬‬
‫‪16‬‬
‫‪14‬‬
‫‪0‬‬
‫‪5‬‬
‫‪25‬‬
‫‪5‬‬
‫‪15‬‬
‫‪10‬‬
‫‪5‬‬
‫‪15‬‬
‫‪1‬‬
‫‪2‬‬
‫‪3‬‬
‫ביקוש‬
‫העתק את הטבלה למחברתך והשלם את הפתרון הבסיסי האפשרי לפי שיטת הפינה ‬
‫‪i‬‬
‫‬
‫הצפונית מערבית‪.‬‬
‫‬
‫‪ i i‬משנים את המחיר בתא )‪ (3 , 1‬מ־ ‪ 0‬ל־ ‪ . 15‬האם ישתנה הפתרון הבסיסי האפשרי ‬
‫‬
‫שמצאת בתת־סעיף ‪ ? i‬נמק‪.‬‬
‫‬
‫ב‪ .‬בטבלה שלפניך נתון פתרון בסיסי אפשרי לבעיית תובלה ונתון ערכו של ‪. u1‬‬
‫‪ui‬‬
‫היצע‬
‫‪0‬‬
‫‪15‬‬
‫יעדים‬
‫‪4‬‬
‫‪24‬‬
‫‪5‬‬
‫‪10‬‬
‫‪5‬‬
‫‪20‬‬
‫‪25‬‬
‫‪5‬‬
‫‪11‬‬
‫‪3‬‬
‫‪2‬‬
‫‪19‬‬
‫‪15‬‬
‫‪18‬‬
‫‪1‬‬
‫‪12‬‬
‫‪10‬‬
‫‪0‬‬
‫‪24‬‬
‫‪5‬‬
‫‪10‬‬
‫‪10‬‬
‫‪5‬‬
‫‪7‬‬
‫‪26‬‬
‫‪15‬‬
‫מקורות‬
‫‪15‬‬
‫‪5‬‬
‫‪1‬‬
‫‪2‬‬
‫‪3‬‬
‫ביקוש‬
‫‪vj‬‬
‫‬
‫‬
‫‬
‫‪i‬‬
‫‪ii‬‬
‫העתק את הטבלה למחברתך והשלם בה את הערכים של ‪. u2 , u3 , v1 , v2 , v3 , v 4‬‬
‫הסבר מדוע הפתרון הנתון אינו פתרון אופטימלי‪.‬‬
‫‪/‬המשך בעמוד ‪/23‬‬
‫ ‪- 23‬‬‫ג‪.‬‬
‫‬
‫‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫בטבלה שלפניך נתון חלק מפתרון בסיסי אפשרי לבעיית תובלה‪ ,‬ונתונים ערכיהם של‬
‫‪ u1 , u2 , u3 , v1 , v2 , v3 , v 4‬שמתאימים לפתרון זה‪.‬‬
‫‪ui‬‬
‫היצע‬
‫‪-7‬‬
‫‪15‬‬
‫‪- 10‬‬
‫‪25‬‬
‫‪0‬‬
‫‪5‬‬
‫יעדים‬
‫‪4‬‬
‫‪3‬‬
‫‪11‬‬
‫‪2‬‬
‫‪20‬‬
‫‪1‬‬
‫‪10‬‬
‫‪10‬‬
‫מקורות‬
‫‪10‬‬
‫‪5‬‬
‫‪19‬‬
‫‪20‬‬
‫‪7‬‬
‫‪15‬‬
‫‪18‬‬
‫‪12‬‬
‫‪10‬‬
‫‪16‬‬
‫‪0‬‬
‫‪14‬‬
‫‪5‬‬
‫‪10‬‬
‫‪15‬‬
‫‪15‬‬
‫‪18‬‬
‫‪29‬‬
‫‪17‬‬
‫‪0‬‬
‫‪vj‬‬
‫ד‪.‬‬
‫נתונה טבלה אשר מייצגת בעיית תובלה מסוימת‪.‬‬
‫יעדים‬
‫‪C‬‬
‫‪D‬‬
‫‪25‬‬
‫‪5‬‬
‫‪10‬‬
‫‪3‬‬
‫‪5‬‬
‫‬
‫‪15‬‬
‫‪2‬‬
‫ביקוש‬
‫העתק את הטבלה למחברתך והשלם את הפתרון תוך התחשבות בערכים של‬
‫‪ u1 , u2 , u3 , v1 , v2 , v3 , v 4‬כך שיתקבל פתרון בסיסי אפשרי‪.‬‬
‫היצע‬
‫‪1‬‬
‫‪B‬‬
‫מקורות‬
‫‪A‬‬
‫‪11‬‬
‫‪20‬‬
‫‪10‬‬
‫‪10‬‬
‫‪20‬‬
‫‪19‬‬
‫‪7‬‬
‫‪12‬‬
‫‪18‬‬
‫‪16‬‬
‫‪14‬‬
‫‪0‬‬
‫‪15‬‬
‫‪15‬‬
‫‪5‬‬
‫‪1‬‬
‫‪2‬‬
‫‪3‬‬
‫ביקוש‬
‫משנים את הביקוש של היעד ‪ C‬מ־ ‪ 15‬ל־ ‪ , 20‬בלי לשנות את שאר הביקושים וההיצעים‬
‫‬
‫שבטבלה‪ .‬סרטט במחברתך טבלה חדשה אשר תכלול את כל הנתונים שבטבלה הנתונה‪,‬‬
‫ותאפשר למצוא פתרון בסיסי אפשרי לפי שיטת הפינה הצפונית מערבית‪ .‬בטבלה יש לכלול‬
‫את המחירים מכל מקור לכל יעד‪.‬‬
‫(שים לב‪ :‬סעיף ה של השאלה בעמוד הבא‪).‬‬
‫‪/‬המשך בעמוד ‪/24‬‬
‫ ‪- 24‬‬‫ה‪.‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫בטבלה שלפניך נתון פתרון לא אופטימלי שהתקבל לאחר ‪ k‬איטרציות בעבור בעיית תובלה‬
‫מסוימת‪ ,‬ונתונים ערכיהם של ‪. u1 , u2 , u3 , v1 , v2 , v3 , v 4‬‬
‫‬
‫‪ui‬‬
‫היצע‬
‫‪0‬‬
‫‪15‬‬
‫‪-3‬‬
‫‪23‬‬
‫‪-5‬‬
‫‪7‬‬
‫יעדים‬
‫‪4‬‬
‫‪2‬‬
‫‪3‬‬
‫‪31‬‬
‫‪20‬‬
‫‪20‬‬
‫‪19‬‬
‫‪1‬‬
‫‪10‬‬
‫‪3‬‬
‫‪18‬‬
‫‪10‬‬
‫‪6‬‬
‫‪9‬‬
‫‪15‬‬
‫מקורות‬
‫‪12‬‬
‫‪7‬‬
‫‪5‬‬
‫‪20‬‬
‫‪0‬‬
‫‪14‬‬
‫‪7‬‬
‫‪1‬‬
‫‪2‬‬
‫‪3‬‬
‫‪10‬‬
‫‪15‬‬
‫‪14‬‬
‫‪6‬‬
‫ביקוש‬
‫‪23‬‬
‫‪22‬‬
‫‪10‬‬
‫‪10‬‬
‫‪vj‬‬
‫‪i‬‬
‫מהו המשתנה היוצא מהבסיס?‬
‫‪ii‬‬
‫סרטט במחברתך טבלה חדשה ובה הפתרון שיתקבל לאחר עוד איטרציה‪ ,‬כלומר‬
‫‬
‫לאחר האיטרציה ה־ ‪. k+1‬‬
‫‪/‬המשך בעמוד ‪/25‬‬
‫‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫ ‪- 25‬‬‫מודלים חישוביים‬
‫אם למדת מסלול זה‪ ,‬ענה על שתיים מהשאלות ‪( 16-13‬לכל שאלה — ‪ 25‬נקודות)‪.‬‬
‫‪ .13‬בשאלה זו שני סעיפים א‪-‬ב‪ ,‬שאין קשר ביניהם‪ .‬ענה על שניהם‪.‬‬
‫א‪.‬‬
‫לפניך השפה ‪ L‬מעל הא"ב }‪: {0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9‬‬
‫‬
‫מילה שייכת לשפה ‪ L‬אם מכפלת כל הספרות המרכיבות את המילה מתחלקת ב־ ‪10‬‬
‫‬
‫ללא שארית‪.‬‬
‫‬
‫דוגמאות למילים ב־ ‪: L‬‬
‫‬
‫‪ , 325‬כי ‪ 3*2*5 = 30‬ו־ ‪ 30‬מתחלק ב־ ‪ 10‬ללא שארית‪.‬‬
‫‬
‫‬
‫‪ , 30675‬כי ‪ 3*0*6*7*5 = 0‬ו־ ‪ 0‬מתחלק ב־ ‪ 10‬ללא שארית‪.‬‬
‫‪ , 543‬כי ‪ 5*4*3 = 60‬ו־ ‪ 60‬מתחלק ב־ ‪ 10‬ללא שארית‪.‬‬
‫‬
‫דוגמאות למילים שאינן ב־ ‪: L‬‬
‫‬
‫‪ , 123‬כי ‪ 1*2*3 = 6‬ו־ ‪ 6‬אינו מתחלק ב־ ‪ 10‬ללא שארית‪.‬‬
‫‬
‫‪ , 51‬כי ‪ 5*1 = 5‬ו־ ‪ 5‬אינו מתחלק ב־ ‪ 10‬ללא שארית‪.‬‬
‫‬
‫‬
‫נסמן‪. Z = {2 , 4 , 6 , 8} D = {1 , 3 , 7 , 9} :‬‬
‫‬
‫לפניך סרטוט חלקי של אוטומט סופי דטרמיניסטי המקבל את השפה ‪. L‬‬
‫‬
‫בסרטוט חסרים מעברים וסימני קלט‪.‬‬
‫‬
‫‪q‬‬
‫‪1‬‬
‫‪Z‬‬
‫‪0‬‬
‫‬
‫‪q2‬‬
‫‪D‬‬
‫‪q0‬‬
‫‪5‬‬
‫‪0‬‬
‫‪q3‬‬
‫‪5,D‬‬
‫‬
‫‬
‫‬
‫‬
‫הסרטוט מכיל את כל המצבים של האוטומט‪ ,‬ואת כל המצבים המקבלים‪.‬‬
‫העתק למחברתך את הסרטוט‪ ,‬והשלם אותו כך שהאוטומט יקבל את השפה ‪. L‬‬
‫עליך להשלים את המעברים החסרים ואת סימני הקלט החסרים‪.‬‬
‫שים לב‪ :‬אין להוסיף מצבים לאוטומט ואין להוריד ממנו מצבים‪.‬‬
‫(שים לב‪ :‬סעיף ב בעמוד הבא‪).‬‬
‫‪/‬המשך בעמוד ‪/26‬‬
‫ ‪- 26‬‬‫‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫ב‪.‬‬
‫(אין קשר לסעיף א‪).‬‬
‫‬
‫לפניך אוטומט סופי לא דטרמיניסטי המקבל את השפה ‪ L‬מעל הא"ב }‪. {0 , 1‬‬
‫‬
‫‪0, 1‬‬
‫‪q3‬‬
‫‪1‬‬
‫‪q2‬‬
‫‪q4‬‬
‫‪0‬‬
‫‪q1‬‬
‫‪0‬‬
‫‪q0‬‬
‫‪1‬‬
‫‪q5‬‬
‫‪0, 1‬‬
‫‬
‫‪0, 1‬‬
‫‬
‫(‪ ) 1‬העתק למחברתך כל אחת מחמש המילים ‪ v-i‬שלפניך‪.‬‬
‫‬
‫לכל אחת מהמילים קבע אם היא מתקבלת על ידי האוטומט או אינה מתקבלת‪.‬‬
‫‬
‫אם המילה מתקבלת על ידי האוטומט‪ ,‬רשום במחברתך את המסלול המקבל‬
‫‬
‫בעבור מילה זו‪.‬‬
‫‬
‫‪i‬‬
‫‬
‫‪000‬‬
‫‬
‫‪ii‬‬
‫‪01000‬‬
‫‬
‫‪iii‬‬
‫‪1100‬‬
‫‬
‫‪iv‬‬
‫‪00101‬‬
‫‬
‫‪v‬‬
‫‪1011‬‬
‫‬
‫(‪ ) 2‬מהי השפה ‪ L‬המוגדרת על ידי האוטומט הנתון?‬
‫‪/‬המשך בעמוד ‪/27‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫‪- 27 -‬‬
‫‪ .14‬בשאלה זו שני סעיפים‪ ,‬א‪-‬ב‪ ,‬שאין קשר ביניהם‪ .‬ענה על שניהם‪.‬‬
‫‬
‫א‪.‬‬
‫לפניך השפה ‪ L‬מעל הא"ב }‪: {0 , 1‬‬
‫{‪ n + k‬זוגי ‪L = {0 n 1 k ; n 2 0 , k $ 0 ,‬‬
‫‬
‫‬
‫לפניך סרטוט חלקי של אוטומט סופי דטרמיניסטי המקבל את השפה ‪. L‬‬
‫‬
‫בסרטוט חסרים מעברים וסימני קלט‪.‬‬
‫‪q2‬‬
‫‬
‫‪0‬‬
‫‪0‬‬
‫‪q1‬‬
‫‪q0‬‬
‫‪1‬‬
‫‪q3‬‬
‫‬
‫‪1‬‬
‫‪q4‬‬
‫‪0‬‬
‫‪q5‬‬
‫‪0,1‬‬
‫‬
‫‬
‫הסרטוט מכיל את כל המצבים של האוטומט‪ ,‬ואת כל המצבים המקבלים‪.‬‬
‫‬
‫העתק למחברתך את הסרטוט‪ ,‬והשלם אותו כך שהאוטומט יקבל את השפה ‪. L‬‬
‫‬
‫עליך להשלים את המעברים החסרים ואת סימני הקלט החסרים‪.‬‬
‫‬
‫שים לב‪ :‬אין להוסיף מצבים לאוטומט‪ ,‬ואין להוריד ממנו מצבים‪.‬‬
‫(שים לב‪ :‬סעיף ב בעמוד הבא‪).‬‬
‫‪/‬המשך בעמוד ‪/28‬‬
‫ ‪- 28‬‬‫ב‪.‬‬
‫‬
‫‬
‫(אין קשר לסעיף א‪).‬‬
‫לפניך אוטומט סופי דטרמיניסטי המקבל את השפה ‪ L‬מעל הא"ב }‪. {a , b‬‬
‫‪q3‬‬
‫‬
‫‬
‫‬
‫‪q2‬‬
‫‪a‬‬
‫‪b‬‬
‫‪q1‬‬
‫‪a‬‬
‫‪q0‬‬
‫אם הטענה אינה נכונה כתוב מילה המפריכה אותה‪.‬‬
‫‪.i‬‬
‫‪.ii‬‬
‫‬
‫‬
‫‪b‬‬
‫‪a‬‬
‫‪b‬‬
‫לכל אחת מהטענות ‪ iii - i‬שלפניך קבע אם היא נכונה או אינה נכונה‪.‬‬
‫‬
‫‬
‫‪b‬‬
‫‪a‬‬
‫‬
‫‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫‪.iii‬‬
‫‬
‫‪ L‬היא אוסף כל המילים מעל הא"ב }‪ {a , b‬שמכילות את התת־מילה ‪ab‬‬
‫ואינן מסתיימות ב־ ‪. b‬‬
‫‪ L‬היא אוסף כל המילים מעל הא"ב }‪ {a , b‬אשר מסתיימות ב־ ‪b‬‬
‫ואינן מכילות את התת־מילה ‪. ab‬‬
‫‪ L‬היא אוסף כל המילים מעל הא"ב }‪ {a , b‬אשר מסתיימות ב־ ‪b‬‬
‫או אינן מכילות את התת־מילה ‪. ab‬‬
‫‪ L .15‬היא שפה מעל הא"ב }‪.{a , b , c‬‬
‫{‪ k‬הוא השארית המתקבלת מחלוקה של ‪ n‬ב־ ‪, 3‬‬
‫‬
‫בנה אוטומט מחסנית בעבור השפה ‪. L‬‬
‫‪L = {a n b n c k ; n $ 1‬‬
‫‪/‬המשך בעמוד ‪/29‬‬
‫‪- 29 -‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫‪ .16‬בשאלה זו שלושה סעיפים‪ ,‬א‪-‬ג‪ ,‬שאין קשר ביניהם‪ .‬ענה על שלושתם‪.‬‬
‫‬
‫לפניך השפות ‪ L2 , L1‬מעל הא"ב }‪: {a , b‬‬
‫א‪.‬‬
‫‪R‬‬
‫}*}‪L1 = {v : v ; v ! {a , b‬‬
‫} ‪L 2 = {a m b ; m $ 1‬‬
‫ו־ ‪ v R‬היא ההיפוך של המילה ‪. v‬‬
‫‬
‫נתונות שתי מילים ב־ ‪ w1 = a i b : L2‬ו־ ‪ w2 = a j b‬כך ש‪. j ! i :‬‬
‫‬
‫מצא מילה ‪ w‬כך שיתקיים‪:‬‬
‫‬
‫‪L1‬‬
‫‬
‫‪L1‬‬
‫‬
‫ב‪.‬‬
‫}‪L1 = {a n b k c m ; k = max (n , m) , n $1 , m $1‬‬
‫‬
‫ }‪L2 = {as ; s $ 1‬‬
‫‪L1‬‬
‫‬
‫‪L1‬‬
‫‬
‫‬
‫‬
‫!‬
‫‪g‬‬
‫‪w1 : w‬‬
‫‪w2 : w‬‬
‫לפניך השפה ‪ L1‬מעל הא"ב }‪ , {a, b‬והשפה ‪ L2‬מעל הא"ב }‪: {a , b , c‬‬
‫ג‪.‬‬
‫‬
‫‬
‫‬
‫מצא מילה ‪ w‬כך שיתקיים‪:‬‬
‫‬
‫‬
‫‪w2 : w g‬‬
‫נתונות שתי מילים ב־ ‪ , w2 = a j , w1 = a i : L2‬כך ש‪. j 2 i :‬‬
‫‬
‫‬
‫!‬
‫‪w1 : w‬‬
‫לפניך השפה ‪ L1‬מעל הא"ב }‪ , {a , b , c‬והשפה ‪ L2‬מעל הא"ב }‪: {a‬‬
‫‬
‫‬
‫‬
‫*}‪ {a , b‬הוא אוסף כל המילים מעל הא"ב }‪( {a , b‬כולל המילה הריקה)‪,‬‬
‫‬
‫‬
‫‬
‫‬
‫}‪k $ 0‬‬
‫‪= {a n b k ; n $ 0 ,‬‬
‫‪L1‬‬
‫}‪} , {a n b n ; n $ 0‬השארית מהחלוקה של ‪ m + r‬ב־ ‪ 2‬היא ‪L2 = {a m cb r ; 1‬‬
‫(‪ ) 1‬בנה אוטומט סופי דטרמיניסטי המקבל את השפה ‪. L1‬‬
‫(‪ )2‬מהי השפה ‪ ? L1+ L2‬האם היא רגולרית? נמק‪.‬‬
‫(‪ )3‬היעזר בתוצאה שקיבלת בתת־סעיף (‪ , )2‬והסבר מדוע השפה ‪ L2‬אינה רגולרית‪.‬‬
‫‪/‬המשך בעמוד ‪/30‬‬
‫‪- 30 -‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫תכנות מונחה עצמים‬
‫אם למדת מסלול זה ואתה כותב ב־ ‪ ,Java‬ענה על שתיים מהשאלות ‪.20-17‬‬
‫(לכל שאלה — ‪ 25‬נקודות)‬
‫‪ .17‬א‪.‬‬
‫לפניך חלק מהממשק של המחלקה ‪ , Node‬ובו ארבע פעולות‪.‬‬
‫הפעולה בונה חוליה‪ .‬הערך של החוליה הוא ‪,x‬‬
‫ואין לה חוליה עוקבת‪.‬‬
‫הפעולה בונה חוליה‪ .‬הערך של החוליה הוא ‪, x‬‬
‫והחוליה העוקבת לה היא ‪. next‬‬
‫ערכו של ‪ next‬יכול להיות ‪. null‬‬
‫הפעולה מחזירה את החוליה העוקבת‪.‬‬
‫אם אין חוליה עוקבת‪ ,‬הפעולה מחזירה ‪. null‬‬
‫הפעולה מחזירה מחרוזת המתארת את החוליה‪.‬‬
‫)‪Node(T x‬‬
‫)‪Node(T x , Node<T> next‬‬
‫)(‪Node<T> getNext‬‬
‫)(‪String toString‬‬
‫(‪ )1‬מהו המנגנון המאפשר שתי פעולות ששמן זהה באותה מחלקה?‬
‫(‪ )2‬האם אפשר להוסיף לממשק המחלקה ‪ Node‬פעולה בונה שלישית?‬
‫‬
‫אם כן — כתוב כותרת מתאימה לפעולה‪ ,‬אם לא — הסבר מדוע‪.‬‬
‫‪/‬המשך בעמוד ‪/31‬‬
603 ,899205 '‫ מס‬,‫ קיץ תשע"ג‬,'‫מדעי המחשב ב‬
- 31 -
. Node<T> ‫ היורשות את המחלקה‬Node2<T> , Node1<T> ‫נתונות המחלקות‬
.‫ב‬
. Test ‫ במחלקה‬main ‫נתונה הפעולה‬
public class Node1<T> extends Node<T>
{
public Node1(T x)
{ super(x); }
public Node1(T x, Node<T> n) { super(x, n); }
public String toString()
{return "$" + super.toString() + "$";}
}
public class Node2<T> extends Node<T>
{
public Node2(T x)
{ super(x); }
public Node2(T x, Node<T> n) { super(x, n); }
public String toString()
{return "#" + super.toString() + "#";}
}
. (v)-(i) ‫ חסרים חלקי הוראות בשורות המסומנות‬main ‫בפעולה‬
)‫ יהיה (משמאל לימין‬main ‫ כך שפלט הפעולה‬,‫העתק שורות אלה למחברתך והשלם אותן‬
1$2$#3#$4$5
public class Test
{
public static void main(String[] args)
{
Node<Integer> nd =
nd =
(ii)
;
nd =
(iii)
;
nd =
(iv)
;
nd =
(v)
;
while (nd != null)
{
System.out.print(nd);
}
}
}
nd = nd.getNext();
/32 ‫המשך בעמוד‬/
(i)
;
603 ,899205 '‫ מס‬,‫ קיץ תשע"ג‬,'‫מדעי המחשב ב‬
- 32 -
.‫ ענה על שניהם‬.‫ שאין קשר ביניהם‬,‫ב‬-‫ א‬,‫ בשאלה זו שני סעיפים‬.18
:‫לפניך הגדרות‬
.‫א‬
.‫ קבע אם כל אחד מהם תקין או אינו תקין‬. viii-i ,‫לפניך שמונה קטעי תכנית‬
.‫ וקבע אם יש שגיאת הידור (קומפילציה) או שגיאת ריצה‬,‫אם אינו תקין — נמק את קביעתך‬
interface IOne {...}
interface ITwo {...}
interface IThree extends IOne {...}
class C1 implements IOne {...}
class C2 implements ITwo {...}
class C3 implements IThree {...}
class C4 extends C3 implements ITwo {...}
i
ITwo a = new ITwo();
ii
ITwo b = new C2();
iii
C3 c = new C4();
iv
C2 d = new C4();
v
C4 e = new C3();
vi
C4 f = (C4)(new C3());
vii
IOne g1 = new C1();
C4 g2 = new C4();
g1 = g2;
viii
IOne h1 = new C4();
ITwo h2 = new C2();
h2 = h1;
/33 ‫המשך בעמוד‬/
‫‪- 33 -‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫ב‪.‬‬
‫(אין קשר לסעיף א‪).‬‬
‫‬
‫נתונות שתי מחלקות ‪ , B , A‬ונתונה הפעולה ‪ main‬במחלקה ‪. Test‬‬
‫‪public class A‬‬
‫{‬
‫} ;)" " ‪public A(int k) { System.out.print(k +‬‬
‫‬
‫}‬
‫‪public class B extends A‬‬
‫)‪public B(int k‬‬
‫;)‪A a = new A(10‬‬
‫;)" " ‪System.out.print(k +‬‬
‫{‬
‫‬
‫{‬
‫‬
‫‬
‫}‬
‫}‬
‫‪public class Test‬‬
‫} ;)‪public static void main(String[] args) { A a = new B(6‬‬
‫‬
‫המחלקה ‪ B‬אינה עוברת קומפילציה‪.‬‬
‫‪i‬‬
‫הסבר מהי השגיאה‪.‬‬
‫‪i i‬‬
‫תקן את השגיאה שהסברת בתת־סעיף ‪ i‬כך שפלט הפעולה ‪ main‬יהיה‬
‫‬
‫(משמאל לימין) ‪ , 10 6‬מבלי להוסיף פקודות הדפסה או לשנות פקודות הדפסה‬
‫קיימות‪ ,‬ומבלי לשנות את המחלקה ‪. Test‬‬
‫העתק למחברתך את המחלקה ‪ /‬המחלקות שתיקנת‪.‬‬
‫‪i ii‬‬
‫תקן את השגיאה שהסברת בתת־סעיף ‪ i‬כך שפלט הפעולה ‪ main‬יהיה ‪, 6 10 6‬‬
‫מבלי להוסיף פקודות הדפסה או לשנות פקודות הדפסה קיימות‪ ,‬ומבלי לשנות את‬
‫המחלקה ‪. Test‬‬
‫העתק למחברתך את המחלקה ‪ /‬המחלקות שתיקנת‪.‬‬
‫‪/‬המשך בעמוד ‪/34‬‬
‫{‬
‫‬
‫}‬
603 ,899205 '‫ מס‬,‫ קיץ תשע"ג‬,'‫מדעי המחשב ב‬
- 34 .‫ ענה על שניהם‬.‫ שאינם קשורים זה לזה‬,‫ב‬-‫ א‬,‫ בשאלה זו שני סעיפים‬.19
. Run ‫ ו־‬BBB , AAA ‫לפניך פרויקט ובו המחלקות‬
public class AAA
{
protected int x;
public String toString() {return "H"; }
}
public AAA(int k)
{ x = k;
.‫א‬
}
public class BBB extends AAA
{
public BBB(int k)
public AAA convertToAAA() {return new AAA(x);}
}
public String toString()
{ super(k);
{return "T";
}
}
public class Run
{
public static void main (String[] args)
{
AAA s1 = new AAA(10);
BBB s3 = new BBB(30);
AAA s2 = new BBB(20);
System.out.print(s1 + " ");
System.out.print(s2 + " ");
System.out.print(s3 + " ");
System.out.print((AAA)s3 + " ");
System.out.print(s3.convertToAAA());
}
}
.‫ וכתוב את הפלט‬, Run ‫ במחלקה‬main ‫כתוב מעקב אחר הפעולה‬
.‫ ובעבור כל עצם — את ערכי התכונות שלו‬,‫במעקב יש לכתוב את ערכי המשתנים‬
/35 ‫המשך בעמוד‬/
603 ,899205 '‫ מס‬,‫ קיץ תשע"ג‬,'‫מדעי המחשב ב‬
- 35 -
).‫(אין קשר לסעיף א‬
. Test ‫ ו־‬B , A ‫לפניך פרויקט ובו המחלקות‬
public class A
{
public int x;
public A()
{ this(1);
}
public A(int k)
{ this.x = k*10;}
public int m()
{return x;
}
}
public class B extends A
{
public int x;
public B()
{ this(2);
}
public B(int k)
{
super(k + 1);
this.x = super.x + 1;
}
public int m()
{return x;
}
}
public class Test
{
public static void main(String[] args)
{
A a = new A();
System.out.println(a.x);
System.out.println(a.m());
B b = new B();
System.out.println(b.x);
System.out.println(b.m());
a = new B();
System.out.println(a.x);
System.out.println(a.m());
b = (B)a;
System.out.println(b.x);
System.out.println(b.m());
}
}
.‫ וכתוב את הפלט‬, Test ‫ במחלקה‬main ‫כתוב מעקב אחר הפעולה‬
.‫ ובעבור כל עצם — את ערכי התכונות שלו‬,‫במעקב יש לכתוב את ערכי המשתנים‬
/36 ‫המשך בעמוד‬/
.‫ב‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫‪- 36 -‬‬
‫‪ .20‬לפניך תרשים של הייררכיית מחלקות בעבור המחלקות ‪ — Sport‬ספורט‪ — Ball ,‬משחקי כדור‪,‬‬
‫‪ — Judo‬ג'ודו‪ — RelayRace ,‬מרוץ שליחים‪ — Basketball ,‬כדורסל‪ — TableTennis ,‬טניס‬
‫שולחן‪ ,‬והממשקים ‪ — IHall‬ספורט באולם ו־ ‪ — IGroup‬ספורט קבוצתי‪.‬‬
‫‪Sport‬‬
‫מקרא‪:‬‬
‫ספורט‬
‫‪RelayRace‬‬
‫מרוץ שליחים‬
‫‪IHall‬‬
‫ספורט באולם‬
‫ירושה‬
‫מימוש ממשק‬
‫‪Ball‬‬
‫‪Judo‬‬
‫משחקי כדור‬
‫ג’ודו‬
‫‪Basketball‬‬
‫כדורסל‬
‫‪TableTennis‬‬
‫טניס שולחן‬
‫‪IGroup‬‬
‫ספורט קבוצתי‬
‫א‪.‬‬
‫‬
‫(‪ )1‬לפניך ארבע הגדרות‪ . iv-i ,‬קבע אם כל אחת מהן נכונה או אינה נכונה‪.‬‬
‫‬
‫אם אינה נכונה‪ ,‬נמק את קביעתך‪.‬‬
‫;)(‪Sport s1 = new Ball‬‬
‫‪i‬‬
‫;)(‪Sport s2 = new Basketball‬‬
‫‪ii‬‬
‫;)(‪iii Judo b2 = new Sport‬‬
‫;)(‪Basketball b3 = new Sport‬‬
‫‪iv‬‬
‫ (‪ )2‬לפניך שני היגדים‪ .ii-i ,‬קבע אם כל אחד מהם נכון או אינו נכון‪ .‬נמק את קביעתך‪.‬‬
‫‬
‫‬
‫‪i‬‬
‫אפשר להגדיר במחלקה ‪ Ball‬משתנים מסוג ‪ private‬שאינם מוגדרים‬
‫‬
‫במחלקה ‪ Sport‬או במחלקה ‪. Judo‬‬
‫‪i i‬‬
‫אם במחלקה ‪ Sport‬יש הגדרה של משתנה בשם ‪ , title‬בהכרח המחלקות‬
‫‬
‫‪ Ball‬ו־ ‪ Judo‬יורשות אותו‪ ,‬אך אינן יכולות לגשת אליו ישירות‪.‬‬
‫‬
‫ב‪.‬‬
‫‬
‫כתוב כותרת ב־ ‪ Java‬לכל מחלקה ולכל ממשק שבתרשים‪.‬‬
‫‬
‫ג‪.‬‬
‫כתוב ב־ ‪ Java‬פעולה שחתימתה )‪ , public static int count(Sport[] sp‬שתחזיר את‬
‫‬
‫מספר העצמים במערך ‪ sp‬המממשים את שני הממשקים‪.‬‬
‫‬
‫‪/‬המשך בעמוד ‪/37‬‬
‫‪- 37 -‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫תכנות מונחה עצמים‬
‫אם למדת מסלול זה ואתה כותב ב־ ‪ ,C#‬ענה על שתיים מהשאלות ‪.24-21‬‬
‫(לכל שאלה — ‪ 25‬נקודות)‬
‫‪.21‬‬
‫לפניך חלק מהממשק של המחלקה ‪ , Node‬ובו ארבע פעולות‪.‬‬
‫א‪.‬‬
‫הפעולה בונה חוליה‪ .‬הערך של החוליה הוא ‪, x‬‬
‫ואין לה חוליה עוקבת‪.‬‬
‫הפעולה בונה חוליה‪ .‬הערך של החוליה הוא ‪, x‬‬
‫והחוליה העוקבת לה היא ‪. next‬‬
‫ערכו של ‪ next‬יכול להיות ‪. null‬‬
‫הפעולה מחזירה את החוליה העוקבת‪.‬‬
‫אם אין חוליה עוקבת‪ ,‬הפעולה מחזירה ‪. null‬‬
‫הפעולה מחזירה מחרוזת המתארת את החוליה‪.‬‬
‫)‪Node(T x‬‬
‫)‪Node(T x, Node<T> next‬‬
‫)(‪Node<T> GetNext‬‬
‫)(‪string ToString‬‬
‫‬
‫(‪ )1‬מהו המנגנון המאפשר שתי פעולות ששמן זהה באותה מחלקה?‬
‫‬
‫(‪ )2‬האם אפשר להוסיף לממשק המחלקה ‪ Node‬פעולה בונה שלישית?‬
‫‬
‫אם כן — כתוב כותרת מתאימה לפעולה‪ ,‬אם לא — הסבר מדוע‪.‬‬
‫(שים לב‪ :‬סעיף ב בעמוד הבא‪).‬‬
‫‪/‬המשך בעמוד ‪/38‬‬
603 ,899205 '‫ מס‬,‫ קיץ תשע"ג‬,'‫מדעי המחשב ב‬
- 38 -
. Node<T> ‫ היורשות את המחלקה‬Node2<T> , Node1<T> ‫נתונות המחלקות‬
.‫ב‬
public class Node1<T> : Node<T>
{
public Node1(T x) : base(x)
{ }
}
public override string ToString()
{ return "$" + base.ToString() + "$"; }
public Node1(T x, Node<T> n):base(x,n) { }
public class Node2<T> : Node<T>
{
public Node2(T x) : base(x)
{ }
}
public override string ToString()
{ return "#" + base.ToString() + "#"; }
public Node2(T x, Node<T> n):base(x,n) { }
. Test ‫ במחלקה‬Main ‫נתונה הפעולה‬
. )v)-(i( ‫ חסרים חלקי הוראות בשורות המסומנות‬Main ‫בפעולה‬
)‫ יהיה (משמאל לימין‬Main ‫ כך שפלט הפעולה‬,‫העתק שורות אלה למחברתך והשלם אותן‬
1$2$#3#$4$5
public class Test
{
public static void Main ()
{
Node<int> nd =
(i)
;
nd =
(ii)
;
nd =
(iii)
;
nd =
(iv)
;
nd =
(v)
while (nd != null)
{
Console.Write(nd);
nd = nd.GetNext();
}
}
}
/39 ‫המשך בעמוד‬/
;
‫‪- 39 -‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫‪ .22‬בשאלה זו שני סעיפים‪ ,‬א‪-‬ב‪ ,‬שאין קשר ביניהם‪ .‬ענה על שניהם‪.‬‬
‫‬
‫א‪.‬‬
‫לפניך הגדרות‪:‬‬
‫‬
‫לפניך שמונה קטעי תכנית‪ . viii-i ,‬קבע אם כל אחד מהם תקין או אינו תקין‪.‬‬
‫}‪interface IOne {...‬‬
‫}‪interface ITwo {...‬‬
‫}‪interface IThree : IOne {...‬‬
‫}‪class C1 : IOne {...‬‬
‫}‪class C2 : ITwo {...‬‬
‫}‪class C3 : IThree {...‬‬
‫}‪class C4 : C3 , ITwo {...‬‬
‫אם אינו תקין — נמק את קביעתך‪ ,‬וקבע אם יש שגיאת הידור (קומפילציה) או שגיאת ריצה‪.‬‬
‫;)(‪ITwo a = new ITwo‬‬
‫‪i‬‬
‫;)(‪ITwo b = new C2‬‬
‫‪ii‬‬
‫;)(‪iii C3 c = new C4‬‬
‫;)(‪iv C2 d = new C4‬‬
‫;)(‪C4 e = new C3‬‬
‫‪v‬‬
‫;))(‪vi C4 f = (C4)(new C3‬‬
‫;)(‪vii IOne g1 = new C1‬‬
‫;)(‪C4 g2 = new C4‬‬
‫‬
‫;‪g1 = g2‬‬
‫‬
‫;)(‪viii IOne h1 = new C4‬‬
‫;)(‪ITwo h2 = new C2‬‬
‫‬
‫;‪h2 = h1‬‬
‫‬
‫(שים לב‪ :‬סעיף ב בעמוד הבא‪).‬‬
‫‪/‬המשך בעמוד ‪/40‬‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫ ‪- 40‬‬‫ב‪.‬‬
‫(אין קשר לסעיף א‪).‬‬
‫‬
‫נתונות שתי מחלקות ‪ , B , A‬ונתונה הפעולה ‪ Main‬במחלקה ‪. Test‬‬
‫‪public class A‬‬
‫{‬
‫} ;)" " ‪public A(int k) { Console.Write(k +‬‬
‫‬
‫}‬
‫‪public class B : A‬‬
‫{‬
‫)‪public B(int k‬‬
‫‬
‫ {‬
‫‬
‫;)‪A a = new A(10‬‬
‫‬
‫;)" " ‪Console.Write(k +‬‬
‫‬
‫}‬
‫‬
‫}‬
‫‪public class Test‬‬
‫{‬
‫}‬
‫;)‪A a = new B(6‬‬
‫{ )(‪public static void Main‬‬
‫‬
‫}‬
‫המחלקה ‪ B‬אינה עוברת קומפילציה‪.‬‬
‫‪i‬‬
‫הסבר מהי השגיאה‪.‬‬
‫‪i i‬‬
‫תקן את השגיאה שהסברת בתת־סעיף ‪ i‬כך שפלט הפעולה ‪ Main‬יהיה‬
‫(משמאל לימין) ‪ , 10 6‬מבלי להוסיף פקודות הדפסה או לשנות פקודות הדפסה‬
‫קיימות‪ ,‬ומבלי לשנות את המחלקה ‪. Test‬‬
‫העתק למחברתך את המחלקה ‪ /‬המחלקות שתיקנת‪.‬‬
‫‪i ii‬‬
‫תקן את השגיאה שהסברת בתת־סעיף ‪ i‬כך שפלט הפעולה ‪ Main‬יהיה ‪, 6 10 6‬‬
‫מבלי להוסיף פקודות הדפסה או לשנות פקודות הדפסה קיימות‪ ,‬ומבלי לשנות את‬
‫המחלקה ‪. Test‬‬
‫העתק למחברתך את המחלקה ‪ /‬המחלקות שתיקנת‪.‬‬
‫‪/‬המשך בעמוד ‪/41‬‬
603 ,899205 '‫ מס‬,‫ קיץ תשע"ג‬,'‫מדעי המחשב ב‬
- 41 .‫ ענה על שניהם‬.‫ שאין קשר ביניהם‬,‫ב‬-‫ א‬,‫ בשאלה זו שני סעיפים‬.23
. Run ‫ ו־‬BBB , AAA ‫לפניך פרויקט ובו המחלקות‬
.‫א‬
public class AAA
{
protected int x;
public AAA(int k) public override string ToString() { return "H"; }
{ x = k;
}
}
public class BBB: AAA
{
public BBB(int k): base(k)
{
}
public override string ToString() {return "T";
public AAA ConvertToAAA() {return new AAA(x);}
}
}
public class Run
{
public static void Main()
{
AAA s1 = new AAA(10);
BBB s3 = new BBB(30);
AAA s2 = new BBB(20);
Console.Write(s1 + " ");
Console.Write(s2 + " ");
Console.Write(s3 + " ");
Console.Write((AAA)s3 + " ");
Console.Write(s3.ConvertToAAA());
}
}
.‫ וכתוב את הפלט‬, Run ‫ במחלקה‬Main ‫כתוב מעקב אחר הפעולה‬
.‫ ובעבור כל עצם — את ערכי התכונות שלו‬,‫במעקב יש לכתוב את ערכי המשתנים‬
/42 ‫המשך בעמוד‬/
).‫ סעיף ב בעמוד הבא‬:‫(שים לב‬
603 ,899205 '‫ מס‬,‫ קיץ תשע"ג‬,'‫מדעי המחשב ב‬
- 42 ).‫(אין קשר לסעיף א‬
. Test ‫ ו־‬B , A ‫לפניך פרויקט ובו המחלקות‬
public class A
{
public int x;
public A() : this(1)
{
}
public A(int k)
{ this.x = k*10;}
public virtual int M() { return x;
}
}
public class B : A
{
public int x;
public B () : this(2) {
}
public B(int k) : base(k + 1) { this.x = base.x + 1; }
public override int M() { return x;
}
}
public class Test
{
public static void Main()
{
A a = new A();
Console.WriteLine(a.x);
Console.WriteLine(a.M());
B b = new B();
Console.WriteLine(b.x);
Console.WriteLine(b.M());
a = new B();
Console.WriteLine(a.x);
Console.WriteLine(a.M());
b = (B)a;
Console.WriteLine(b.x);
Console.WriteLine(b.M());
}
}
.‫ וכתוב את הפלט‬, Test ‫ במחלקה‬Main ‫כתוב מעקב אחר הפעולה‬
.‫ ובעבור כל עצם — את ערכי התכונות שלו‬,‫במעקב יש לכתוב את ערכי המשתנים‬
/43 ‫המשך בעמוד‬/
.‫ב‬
‫מדעי המחשב ב'‪ ,‬קיץ תשע"ג‪ ,‬מס' ‪603 ,899205‬‬
‫ ‪- 43‬‬‫‪ .24‬לפניך תרשים של הייררכיית מחלקות בעבור המחלקות ‪ — Sport‬ספורט‪ — Ball ,‬משחקי כדור‪,‬‬
‫‪ — Judo‬ג'ודו‪ — RelayRace ,‬מרוץ שליחים‪ — BasketBall ,‬כדורסל‪ — TableTennis ,‬טניס‬
‫שולחן‪ ,‬והממשקים ‪ — IHall‬ספורט באולם ו־ ‪ — IGroup‬ספורט קבוצתי‪.‬‬
‫‪Sport‬‬
‫מקרא‪:‬‬
‫ספורט‬
‫‪RelayRace‬‬
‫מרוץ שליחים‬
‫‪IHall‬‬
‫ספורט באולם‬
‫ירושה‬
‫מימוש ממשק‬
‫‪Ball‬‬
‫‪Judo‬‬
‫משחקי כדור‬
‫ג’ודו‬
‫‪Basketball‬‬
‫כדורסל‬
‫‪TableTennis‬‬
‫טניס שולחן‬
‫‪IGroup‬‬
‫ספורט קבוצתי‬
‫א‪.‬‬
‫‬
‫(‪ )1‬לפניך ארבע הגדרות‪ . iv-i ,‬קבע אם כל אחת מהן נכונה או אינה נכונה‪.‬‬
‫‬
‫אם אינה נכונה‪ ,‬נמק את קביעתך‪.‬‬
‫;)(‪Sport s1 = new Ball‬‬
‫‪i‬‬
‫;)(‪Sport s2 = new Basketball‬‬
‫‪ii‬‬
‫;)(‪iii Judo b2 = new Sport‬‬
‫;)(‪Basketball b3 = new Sport‬‬
‫‪iv‬‬
‫ (‪ )2‬לפניך שני היגדים‪ .ii-i ,‬קבע אם כל אחד מהן נכון או אינו נכון‪ .‬נמק את קביעתך‪.‬‬
‫‬
‫‬
‫‪i‬‬
‫‬
‫‪i i‬‬
‫‬
‫אפשר להגדיר במחלקה ‪ Ball‬משתנים מסוג ‪ private‬שאינם מוגדרים‬
‫במחלקה ‪ Sport‬או במחלקה ‪. Judo‬‬
‫אם במחלקה ‪ Sport‬יש הגדרה של משתנה בשם ‪ , title‬בהכרח המחלקות‬
‫‪ Ball‬ו־ ‪ Judo‬יורשות אותו‪ ,‬אך אינן יכולות לגשת אליו ישירות‪.‬‬
‫‬
‫‬
‫‬
‫ב‪.‬‬
‫‬
‫כתוב כותרת ב־ ‪ C#‬לכל מחלקה ולכל ממשק שבתרשים‪.‬‬
‫‬
‫ג‪.‬‬
‫‬
‫כתוב ב־ ‪ C#‬פעולה שחתימתה )‪ , public static int Count(Sport[] sp‬שתחזיר את מספר‬
‫העצמים במערך ‪ sp‬המממשים את שני הממשקים‪.‬‬
‫בהצלחה!‬
‫זכות היוצרים שמורה למדינת ישראל‬
‫אין להעתיק או לפרסם אלא ברשות משרד החינוך‬