‫אוניברסיטת תל אביב ‪ -‬בית הספר למדעי המחשב‬ ‫מבוא מורחב למדעי המחשב‪ ,‬אביב ‪3102‬‬ ‫תרגיל בית מספר ‪ - 4‬להגשה עד ‪ 6‬במאי בשעה ‪325::‬‬ ‫קיראו בעיון את הנחיות העבודה וההגשה המופיעות באתר הקורס‪ ,‬תחת התיקיה‬ ‫‪ .assignments‬חריגה מההנחיות תגרור ירידת ציון ‪ /‬פסילת התרגיל‪.‬‬ ‫הנחיות ספציפיות לתרגיל זה‪:‬‬ ‫‪ ‬תשובות לשאלות ‪ 2 ,1‬א'‪ 4 ,3 ,‬א'‪ 5 ,‬יש לממש בקובץ השלד (‪ )skeleton.py‬המצורף לתרגיל זה‪ .‬אין‬ ‫לצרף לקובץ ה‪ py-‬את הקוד ששימש לפתרון יתר השאלות‪ .‬לא לשכוח לשנות את שם הקובץ למספר‬ ‫ת"ז שלכם לפני ההגשה‪ ,‬אך להשאיר את הסיומת ‪.py‬‬ ‫שימו לב שבקובץ השלד יש קוד שמבצע בדיקות של כמה מקרים פשוטים (חלק בעזרת ‪ assert‬וחלק‬ ‫בעזרת ‪ - doctest‬לפרטים נוספים על ‪ .)doctest‬היעזרו בקוד זה כדי לוודא נכונות הפלטים שלכם‬ ‫עבור אותם מקרים‪ .‬פתרונות שלא עובדים נכון במקרים פשוטים אלו לא יתקבלו‪ .‬כמובן‪ ,‬על הקוד‬ ‫שלכם להיות נכון לכל קלט תקין‪ ,‬ולא רק למקרים שבדוגמאות‪ .‬אסור לשנות את כותרות הפונקציות‬ ‫שעליכם לממש בקובץ השלד‪.‬‬ ‫‪‬‬ ‫תשובות לכל שאר השאלות יוגשו בקובץ ‪ docx ,doc‬או ‪ pdf‬יחיד‪.‬‬ ‫‪‬‬ ‫בסה"כ מגישים שני קבצים בלבד‪ .‬עבור סטודנט שמספר ת"ז שלו הוא ‪ 012345678‬הקבצים‬ ‫שיש להגיש הם ‪( 012345678.docx‬או ‪ .doc‬או ‪ ).pdf‬ו‪.012345678.py -‬‬ ‫‪‬‬ ‫הקפידו לענות על כל מה שנשאלתם‪.‬‬ ‫‪‬‬ ‫במסמך התשובות‪ ,‬תנו תשובות קולעות וברורות‪ ,‬כל תשובה באורך ‪ 4‬שורות לכל היותר בפונט בגודל‬ ‫‪ .12‬מטרת הגבלת אורך התשובה היא כפולה‪:‬‬ ‫‪ .1‬על מנת שנוכל לבדוק את התרגילים שלכם בזמן סביר‪.‬‬ ‫‪ .2‬כדי להרגיל אתכם להבעת טיעונים באופן מתומצת ויעיל‪ ,‬ללא פרטים חסרים מצד אחד אך‬ ‫ללא עודף בלתי הכרחי מצד שני‪ .‬זוהי פרקטיקה חשובה במדעי המחשב‪.‬‬ ‫עמ' ‪ 1‬מתוך ‪7‬‬ ‫‪CC BY-NC-SA 3.0‬‬ ‫אוניברסיטת תל אביב ‪ -‬בית הספר למדעי המחשב‬ ‫מבוא מורחב למדעי המחשב‪ ,‬אביב ‪3102‬‬ ‫שאלה ‪0‬‬ ‫עליכם לממש מחלקה בשם ‪( Vector‬וקטור) אשר מתארת נקודה במרחב תלת‪-‬ממדי ‪ .R3‬וקטור מיוצג‬ ‫ע"י מרחקו משלושת הצירים – ‪ – X, Y, Z‬אשר מתארים את מיקום הוקטור במרחב‪ .‬שלושת מרחקים‬ ‫אלו הם משתנים פנימיים של המחלקה וקטור‪ .‬המחלקה תהיה ‪ ,immutable‬כלומר‪ ,‬לאחר יצירת מופע‬ ‫חדש של וקטור המתודות של המחלקה לעולם לא ישנו את המשתנים הפנימיים שלו‪ ,‬אלא יחזירו מופע‬ ‫חדש של המחלקה‪.‬‬ ‫בקובץ התרגיל כבר מתוארת המחלקה ועליכם לממש את המתודות שלה‪ .‬במתודות שמקבלות וקטור‬ ‫נוסף כמשתנה (למשל‪ ,‬מתודת __‪ )__add‬יש צורך לבדוק את הטיפוס של המשתנה הנוסף כפי‬ ‫שהודגם בתרגול‪.‬‬ ‫לתשומת לבכם‪ ,‬אמנם בשאלה זו מספר רב של סעיפים‪ ,‬אך את רוב המתודות ניתן לממש בשורת קוד‬ ‫בודדת‪.‬‬ ‫לבדיקה עצמית‪ 5‬בתיעוד כל פונקציה כתוב טסט פשוט‪ ,‬שמאפשר לכם לבדוק את נכונות המימוש‬ ‫שלכם לפונקציה‪ .‬הבדיקה היא באמצעות ‪.doctest‬‬ ‫א‪.‬‬ ‫ממשו את הבנאי __‪ .__init‬הבנאי יקבל את מרחק הוקטור משלושת הצירים ‪ x,y,z‬כשלושה‬ ‫מספרים וישמור אותם במשתנים פנימיים מטיפוס ‪ .float‬לא ייתנו ערכי ברירת‪-‬מחדל למשתני‬ ‫הבנאי‪.‬‬ ‫דוגמא‪:‬‬ ‫)‪>>> u = Vector(1,0,2‬‬ ‫ב‪.‬‬ ‫ממשו את המתודה ‪ .to_tuple‬המתודה אינה מקבלת ארגומנטים (מלבד ‪ )self‬ומחזירה ‪tuple‬‬ ‫באורך ‪ 3‬ובו המרחק של הוקטור מציר ה‪ ,X-‬ציר ה‪ Y -‬וציר ה‪ ,Z-‬לפי הסדר הזה‪ .‬שימו לב‬ ‫שהמתודה __‪ __repr‬כבר ממומשת אך היא נעזרת במתודה ‪ to_tuple‬לפעולתה‪.‬‬ ‫דוגמא‪:‬‬ ‫)(‪>>> u.to_tuple‬‬ ‫)‪(1.0, 0.0, 2.0‬‬ ‫ג‪.‬‬ ‫ממשו את המתודה __‪ :__eq‬מתודה זו בודקת האם שני וקטורים שווים‪ .‬המתודה מקבלת בנוסף‬ ‫ל‪ self-‬וקטור נוסף‪ ,other ,‬ומחזירה ‪ True‬אך ורק אם שני הוקטורים שווים ואחרת מחזירה‬ ‫המתודה ‪.False‬‬ ‫דוגמא‪:‬‬ ‫)‪>>> u == Vector(1,1,1‬‬ ‫‪False‬‬ ‫)‪>>> u == Vector(1,0,2‬‬ ‫‪True‬‬ ‫עמ' ‪ 2‬מתוך ‪7‬‬ ‫‪CC BY-NC-SA 3.0‬‬ ‫אוניברסיטת תל אביב ‪ -‬בית הספר למדעי המחשב‬ ‫מבוא מורחב למדעי המחשב‪ ,‬אביב ‪3102‬‬ ‫ד‪.‬‬ ‫ממשו את אופרטור החיבור ע"י מימוש המתודה __‪ :__add‬המתודה מקבלת שני וקטורים ( ‪self,‬‬ ‫‪ )other‬ומחזירה וקטור חדש שהוא סכום הוקטורים מהקלט‪ .‬שימו לב שחיבור וקטורים הוא לפי‬ ‫איברים – למשל‪ ,‬המרחק של הוקטור החדש מציר ה‪ X-‬הוא סכום מרחקי וקטורי הקלט מציר ה‪.X-‬‬ ‫דוגמא‪:‬‬ ‫)‪>>> u + Vector(1,-3,4‬‬ ‫)‪(2.0, -3.0, 6.0‬‬ ‫‪>>> u‬‬ ‫)‪(1.0, 0.0, 2.0‬‬ ‫ה‪.‬‬ ‫ממשו את אופרטור החיסור ע"י מימוש המתודות __‪ __neg‬ו‪ :__sub__-‬מכיוון שחיסור הוא‬ ‫חיבור בנגדי‪ ,‬ממשו תחילה את המתודה __‪ __neg‬שמחזירה את הוקטור השלילי לוקטור זה‪,‬‬ ‫כלומר‪ ,‬הוקטור שהסכום איתו ייתן (‪ .)0,0,0‬לאחר מכן ממשו את המתודה __‪ __sub‬בעזרת‬ ‫המתודות __‪ __neg‬ו‪.__add__-‬‬ ‫דוגמא‪:‬‬ ‫‪>>> -u‬‬ ‫)‪(-1.0, 0.0, -2.0‬‬ ‫)‪>>> u – Vector(4,3,2‬‬ ‫)‪(-3.0, -3.0, 0.0‬‬ ‫ו‪.‬‬ ‫ממשו את אופרטור הכפל בסקלר ע"י מימוש המתודה __‪ :__mul‬המתודה תקבל מספר שהוא‬ ‫סקלר ותחזיר וקטור חדש שהוא המכפלה של הוקטור בסקלר – כל אחד מערכי הוקטור מוכפל‬ ‫בסקלר‪ .‬שימו לב‪ ,‬עליכם לוודא כי המשתנה בקלט הינו אכן מספר – ‪ int‬או ‪ float‬ע"י שימוש‬ ‫בפונקציה ‪ ,isinstance‬כפי שהודגם בתרגול‪.‬‬ ‫דוגמא‪:‬‬ ‫‪>> u * 2‬‬ ‫)‪(2.0, 0.0, 4.0‬‬ ‫‪>>> u * u‬‬ ‫‪AssertionError:‬‬ ‫ז‪.‬‬ ‫ממשו את המתודה ‪ inner‬שמקבלת וקטור נוסף כמשתנה ומחשבת את המכפלה הפנימית‪ .‬חישוב‬ ‫המכפלה הפנימית של שני וקטורים מחזיר סקלר (‪ )float‬לפי הנוסחה הבאה‪ ,‬עבור המכפלה‬ ‫הפנימית של הוקטורים ‪:u, v‬‬ ‫עמ' ‪ 3‬מתוך ‪7‬‬ ‫‪CC BY-NC-SA 3.0‬‬ ‫אוניברסיטת תל אביב ‪ -‬בית הספר למדעי המחשב‬ ‫מבוא מורחב למדעי המחשב‪ ,‬אביב ‪3102‬‬ ‫דוגמא‪:‬‬ ‫))‪>>> u.inner(Vector(1,2,4‬‬ ‫‪9.0‬‬ ‫))‪>>> u.inner(Vector(-2,3,1‬‬ ‫‪0.0‬‬ ‫ח‪.‬‬ ‫ממשו את המתודה ‪ norm‬אשר מחשבת את הנורמה של וקטור‪ :‬ממשו את המתודה בעזרת‬ ‫המתודה ‪ inner‬והפונקציה ‪ sqrt‬מהמודול ‪ .math‬המתודה תחזיר את השורש של המכפלה‬ ‫הפנימית של הוקטור עם עצמו‪ ,‬ולא תקבל ארגומנטים (מעבר ל‪.)self-‬‬ ‫דוגמא‪:‬‬ ‫)(‪>>> u.norm‬‬ ‫‪2.2360679774997898‬‬ ‫)(‪>>> Vector(1,2,2).norm‬‬ ‫‪3.0‬‬ ‫שאלה ‪3‬‬ ‫א‪ .‬כתבו פונקציה )‪ k_select(lst, k‬שמקבלת רשימת מספרים ‪ lst‬באורך ‪ n‬ומספר שלם ‪0≤k<n‬‬ ‫ומחזירה את המספר ה‪ k+1-‬בגודלו ברשימה – הוא המספר שיש בדיוק ‪ k‬מספרים שקטנים ממנו‬ ‫ממש‪.‬‬ ‫על המימוש להיות רקורסיבי ואין להשתמש בפונקציות ‪ sorted‬או ‪ .sort‬ניתן להניח שהמספרים‬ ‫בקלט יחודיים‪ ,‬כלומר‪ ,‬שאין מספרים שחוזרים על עצמם‪ .‬אם ‪ k‬קטן מדי או גדול מדי יש לזרוק‬ ‫שגיאה באמצעות ‪.assert‬‬ ‫הנחיה‪ :‬המימוש יתבצע באופן דומה למימוש ‪ Slowsort‬שהודגם בתרגול‪:‬‬ ‫‪ ‬עבור רשימה באורך ‪ n‬יש לבחור כציר (‪ )pivot‬את האיבר הראשון ברשימה‬ ‫‪ ‬יש לחלק את הרשימה לשתי תתי‪-‬רשימות –‬ ‫‪ o‬האיברים שקטנים ממש מהציר ברשימה אחת – "קטנים"‬ ‫‪ o‬האיברים שגדולים ממש מהציר ברשימה שניה – "גדולים"‬ ‫‪ ‬יש לבדוק‪ ,‬לפי אורכי "קטנים" ו"גדולים" ולפי ‪ k‬האם האיבר ה‪ k-‬נמצא ברשימה "קטנים"‪,‬‬ ‫"גדולים" או שאולי הוא איבר הציר‪.‬‬ ‫‪ ‬אם הוא באחת הרשימות‪ ,‬יש למצוא אותו ע"י קריאה רקורסיבית על הרשימה המתאימה‪.‬‬ ‫‪ ‬שימו לב שכל קריאה ל‪ k_select-‬מייצרת קריאה רקורסיבית אחת לכל היותר‪.‬‬ ‫דוגמאות הרצה‪:‬‬ ‫)‪>>> k_select([5,4,7,6,8,2,3], 2‬‬ ‫‪4‬‬ ‫)‪>>> k_select([5,4,7,6,8,2,3], 5‬‬ ‫‪7‬‬ ‫)‪>>> k_select([5,4,7,6,8,2,3], 0‬‬ ‫‪2‬‬ ‫ב‪ .‬בהינתן קלט תקין‪ ,‬מצאו מה סיבוכיות הזמן של האלגוריתם שמומש בסעיף א' בתלות באורך‬ ‫הקלט עבור המקרה הטוב ביותר‪ ,‬ונמקו בקצרה‪ .‬ציינו גם מהו הקלט שמתאים למקרה זה‪.‬‬ ‫עמ' ‪ 4‬מתוך ‪7‬‬ ‫‪CC BY-NC-SA 3.0‬‬ ‫אוניברסיטת תל אביב ‪ -‬בית הספר למדעי המחשב‬ ‫מבוא מורחב למדעי המחשב‪ ,‬אביב ‪3102‬‬ ‫ג‪.‬‬ ‫ד‪.‬‬ ‫בהינתן קלט תקין‪ ,‬מצאו מה סיבוכיות הזמן של האלגוריתם שמומש בסעיף א' בתלות באורך‬ ‫בקלט עבור המקרה הגרוע ביותר‪ ,‬ונמקו בקצרה‪ .‬ציינו גם מהו הקלט שמתאים למקרה זה‪.‬‬ ‫השוו בעזרת הפונקציה ‪ clock‬במודול ‪ time‬את זמן הריצה של הפונקציה שממשתם בסעיף א'‬ ‫לעומת זמן הריצה של מימוש בעזרת ‪:sorted‬‬ ‫]‪>>> sorted(lst)[k‬‬ ‫לצורך ההשוואה‪ ,‬השתמשו ברשימת המספרים מ‪ 1-‬עד ‪ ,n‬מסודרים אקראית‪:‬‬ ‫‪>>> import random‬‬ ‫])‪>>> lst = [i for i in range(1, 100‬‬ ‫(‪>>> random.shuffle(lst‬‬ ‫מהי מסקנתכם? האם יש הבדל בתשובתכם עבור רשימה באורך ‪ 10‬ועבור רשימה באורך‬ ‫‪?1,000,000‬‬ ‫שאלה ‪2‬‬ ‫בשאלה זו עליכם לכתוב את הפונקציה הרקורסיבית )‪.choose_sets(lst, k‬‬ ‫הפונקציה מקבלת רשימה של איברים ‪ lst‬ומספר שלם ‪ ,k‬ומחזירה רשימה המכילה את כל הרשימות‬ ‫השונות באורך ‪ k‬שניתן ליצור מאיברי ‪ ,lst‬ללא חשיבות לסדר האיברים‪ .‬כלומר‪ ,‬את כל האפשרויות‬ ‫לבחור ‪ k‬איברים מתוך הרשימה ‪ ,lst‬ללא חשיבות לסדר הבחירה‪ .‬ניתן להניח שאיברי הרשימה ‪lst‬‬ ‫יחודיים‪ ,‬כלומר‪ ,‬שאין איברים שחוזרים על עצמם‪.‬‬ ‫שימו לב‪:‬‬ ‫‪‬‬ ‫‪‬‬ ‫‪‬‬ ‫‪‬‬ ‫כאן אנו מעונינים ממש באפשרויות השונות לבחור ‪ k‬איברים‪ ,‬ולא רק בכמה אפשרויות כאלו‬ ‫יש‪.‬‬ ‫הערך המוחזר הוא רשימה של רשימות‪ ,‬וכל אחת מהרשימות הללו הינה בדיוק באורך ‪.k‬‬ ‫סדר הרשימות בתוך רשימת העל אינו חשוב‪.‬‬ ‫כאמור‪ ,‬הסדר הפנימי בכל תת‪-‬רשימה אינו חשוב‪ ,‬ואסור שיהיו כפילויות‪ .‬לדוגמא‪ ,‬הרשימה‬ ‫]‪ [1,2,3‬שקולה לרשימה ]‪.[3,2,1‬‬ ‫הנחיה‪:‬‬ ‫‪‬‬ ‫‪‬‬ ‫‪‬‬ ‫ניתן לקבל את כל התת‪-‬רשימות באורך ‪ k‬ע"י איסוף של כל תת‪-‬הרשימות שמכילות את האיבר‬ ‫הראשון ברשימה וכל תת‪-‬הרשימות שאינן מכילות את האיבר הראשון ברשימה‪.‬‬ ‫שימו לב לערך ההחזרה של מקרה הבסיס (תנאי ההתחלה)‪.‬‬ ‫ניתן להניח כי הקלט תקין – אין חזרות של איברים ברשימת הקלט ו‪ 0≤k≤n-‬הוא מספר שלם‪,‬‬ ‫כאשר ‪ n‬הוא אורך הרשימה ‪.lst‬‬ ‫דוגמאות הרצה‪:‬‬ ‫(‪>>> choose_sets([1,2,3, 4], 0‬‬ ‫[[]]‬ ‫(‪>>> choose_sets([1,2,3, 4], 2‬‬ ‫[[‪]]4 ,3[ ,]2 ,4[ ,]2 ,3[ ,]1 ,4[ ,]1 ,3[ ,]1 ,2‬‬ ‫(‪>>> choose_sets([1,2,3, 4], 4‬‬ ‫עמ' ‪ 5‬מתוך ‪7‬‬ ‫‪CC BY-NC-SA 3.0‬‬ ‫אוניברסיטת תל אביב ‪ -‬בית הספר למדעי המחשב‬ ‫מבוא מורחב למדעי המחשב‪ ,‬אביב ‪3102‬‬ ‫[[‪]]4 ,3 ,2 ,1‬‬ ‫(‪>>> choose_sets(['a','b','c','d','e'], 4‬‬ ‫]]'‪[['d', 'c', 'b', 'a'], ['e', 'c', 'b', 'a'], ['d', 'e', 'b', 'a'], ['c', 'd', 'e', 'a'], ['b', 'c','d', 'e‬‬ ‫שאלה ‪4‬‬ ‫א‪.‬‬ ‫בשאלה זו תממשו את אלגוריתם המיון ‪ Selection sort‬באופן רקורסיבי‪ ,‬בפונקציה‬ ‫)‪.selection_sort(lst‬‬ ‫הנחיה‪:‬‬ ‫‪‬‬ ‫‪‬‬ ‫‪‬‬ ‫‪‬‬ ‫בהינתן קלט של רשימה‪ ,‬הפונקציה מוצאת את האיבר המינימלי ברשימה‪.‬‬ ‫כעת ניתן לקרוא שוב לפונקציה על אותה רשימה ללא האיבר המינימלי הנ"ל‪ ,‬ובכך מקטינים‬ ‫את הרשימה שהפונקציה מקבלת באיבר אחד ואורך הקלט משתנה מ‪ n-‬ל‪ .n-1-‬זהו הפירוק‬ ‫של הרקורסיה‪.‬‬ ‫תנאי העצירה הוא רשימה בגודל ‪.1‬‬ ‫אין צורך לבדוק את טיפוס הקלט וניתן להניח שהוא מטיפוס ‪.list‬‬ ‫דוגמא‪:‬‬ ‫)]‪>>> selection_sort([5, 4, 6, 3‬‬ ‫]‪[3, 4, 5, 6‬‬ ‫])‪>>> lst = [random.randint(1, 55) for i in range(100‬‬ ‫(‪>>> selection_sort(lst) == sorted(lst‬‬ ‫‪True‬‬ ‫ב‪.‬‬ ‫ג‪.‬‬ ‫ד‪.‬‬ ‫מה סיבוכיות הזמן של ‪ Selection sort‬במקרה הגרוע ביותר? הסבירו בקצרה‪.‬‬ ‫האם יש הבדל בין הסיבוכיות במקרה הגרוע ביותר לבין הסיבוכיות במקרה הטוב ביותר?‬ ‫מה עומק הרקורסיה עבור רשימה בגודל ‪?n‬‬ ‫שאלה ‪:‬‬ ‫עץ בינארי (‪ )binary tree‬הינו מבנה נתונים נפוץ במדעי המחשב‪ .‬עץ בינארי מורכב מקודקודים (‪)nodes‬‬ ‫המכילים ערכים‪ .‬לכל קודקוד לכל היותר שני קודקודים בנים‪ :‬בן ימני ובן שמאלי‪ .‬החיבור בין קודקוד לבנו‬ ‫נקרא קשת )‪ .(edge‬הקודקוד שבראש העץ נקרא שורש (‪ .)root‬הקודקודים בתחתית העץ (אשר להם אין‬ ‫קודקודים בנים) נקראים עלים (‪ .)leaves‬לשם המחשה‪ ,‬מובא עץ בינארי לדוגמא (הציור לקוח מתוך האתר‬ ‫‪:)http://www.squidoo.com/computer-trees‬‬ ‫עמ' ‪ 6‬מתוך ‪7‬‬ ‫‪CC BY-NC-SA 3.0‬‬ ‫אוניברסיטת תל אביב ‪ -‬בית הספר למדעי המחשב‬ ‫מבוא מורחב למדעי המחשב‪ ,‬אביב ‪3102‬‬ ‫עץ בינארי יכול להכיל קודקוד אחד (שהינו גם שורש העץ וגם עלה בו זמנית)‪ ,‬או אפילו להיות עץ ריק (אינו‬ ‫מכיל קודקודים כלל)‪.‬‬ ‫בשאלה זו נחשב את גובהו של עץ בינארי נתון‪.‬‬ ‫נגדיר תחילה מחלקה המייצגת קודקוד בעץ‪ .‬כל קודקוד מכיל שלושה שדות‪:‬‬ ‫‪ .1‬ערך הקודקוד‬ ‫‪ .2‬הבן הימני של הקודקוד (או ‪ None‬אם לא קיים)‬ ‫‪ .3‬הבן השמאלי של הקודקוד (או ‪ None‬אם לא קיים)‪.‬‬ ‫הבנאי (__‪ )__init‬של המחלקה נתון בקובץ הקוד המצורף‪.‬‬ ‫א‪ .‬הוסיפו למחלקה ‪ Node‬מתודה בשם ‪ add_child‬המוסיפה בן לקודקוד קיים‪ .‬המתודה מקבלת שני‬ ‫ארגומנטים‪ )1( :‬הצד שאליו מתווסף הבן ו‪ )2(-‬הבן שיש להוסיף (אובייקט מטיפוס ‪ Node‬בעצמו)‪,‬‬ ‫ומעדכנת את הקודקוד הקיים‪ .‬הצד יצוין על ידי האותיות (מחרוזות באורך ‪ L )1‬או ‪( R‬שמאל וימין‪,‬‬ ‫בהתאמה) בלבד‪ .‬אין צורך לבדוק האם כבר קיים בן בצד המבוקש‪.‬‬ ‫לאחר הוספת המתודה‪ ,‬אם נריץ את הפונקציה ‪ build_diagram‬הנתונה בקובץ הקוד‪ ,‬נקבל את‬ ‫העץ המתואר בתרשים הנ"ל‪ .‬אפשר להניח שפעולת ההוספה אינה יוצרת מעגלים בעץ (אין צורך‬ ‫לבדוק זאת)‪.‬‬ ‫ב‪ .‬הוסיפו מתודה בשם )‪ is_leaf(self‬המחזירה ‪ True‬אם הקודקוד הינו עלה (קצה העץ)‪ ,‬ואחרת‬ ‫מחזירה ‪.False‬‬ ‫ג‪ .‬כתבו פונקציה רקורסיבית בשם ‪ tree_height‬המקבלת עץ ומחשבת את "גובה" העץ‪ .‬גובה של‬ ‫עץ מוגדר כמספר הקשתות בענף הארוך ביותר (למשל‪ ,‬עבור העץ שדוגמה התשובה היא ‪ .)2‬ענף‬ ‫הוא מסלול של קודקודים שמוביל משורש לעלה‪.‬‬ ‫הפונקציה אינה שייכת למחלקה ‪.Node‬‬ ‫עץ מצוין על ידי שורשו‪ ,‬ועל כן הפונקציה מקבלת למעשה אובייקט מסוג ‪ Node‬שהוא שורש העץ‬ ‫או ‪ None‬במקרה של עץ ריק‪.‬‬ ‫סוף‪.‬‬ ‫עמ' ‪ 7‬מתוך ‪7‬‬ ‫‪CC BY-NC-SA 3.0‬‬