20 Job Interviews and Answers

וראיונות? לטלפונים לחכות לך נמאסאיתנו קורות החיים שלך יגיעו לידיים הנכונות!

JobHunt.co.il

חומר טכני לראיון עבודה

תיאור כללי:.1."חלק "צפוי."חלק "בלתי צפוי.דוגמא לתיאור של פרויקט

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

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

תשובות לחלק מהשאלות.4


JobHunt.co.il

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

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

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

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

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

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

חלק "בלתי צפוי" בחלק הזה שואלים אותך שאלות טכניות או חידות. השאלות הטכניות יכולות להיות דברים.4

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

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

אי אפשר ממש לצפות מראש איזה שאלות תישאל בחלק הזה. בדרך כלל המראיין לא מצפה.5 שתחשוב לבד ותשלוף ישר את הפתרון הסופי, אלא שתתאר בקול רם איך אתה חושב לפתור

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

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

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

דוגמא לתיאור של פרויקט. תיאור כללי: ...1. מעבד: ...2. מערכת הפעלה: ...3. סביבת פיתוח: ...4. שפת תכנות: ...5. בקרת תצורה: ...6. תיאור מפורט: ...7. חבילת עבודה עיקרית: ...8


JobHunt.co.il

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

לגבי הקושי של הראיון בכל מקום ספציפי(:

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

בהתחלה וכל הירוקים יהיו בסוף. אין לך שטח זיכרון נוסף להשתמש בו.יש לך רשימה מקושרת. כתוב פונקציה שהופכת אותה..2

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

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

במערכת שתיכננת? מתחיל בנקודת זמן מסויימת, מסייםTask'ים שרצים במערכת ההפעלה. כל Taskנתונים .4

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

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

Pendבכל פעם שהוא עובר למצב המתנה(. הוסף למחלקה פונקציה שמקבלת את הזמן (.Run, Pend, Not-Aliveשהאובייקט מתאר )Task הנוכחי במערכת ומחזירה את מצב ה-

הרחב את האובייקט כך שתוכל לדעת כמה אובייקטים קיימים במערכת בכל רגע נתון..5?++C ב-Static? מה זה C ב-Staticמה זה .6

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

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

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

עצמים של מחלקות שנגזרות ממנה(. איך תממש את המחלקה כך שלא יהיה ניתן ליצורInstance?ים שלה'

BATM)יוקנעם( מנורות בטור. כולן מכובות. איש ראשון עובר ולוחץ על כל מפסק. איש שני עובר100נתונות .9

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

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

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


JobHunt.co.il

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

הכדורים כך שיהיה לי הכי הרבה סיכוי להצליח? קומות. יש קומה מסויימת, שממנה והלאה הכדורים100יש לך שני כדורי זכוכית ובניין בן .12

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

האפשר של נסיונות.

IBM)חיפה( אתה נמצא על כביש חד סטרי. כל כמה זמן אתה עובר מול בית. יש לך מצלמה שיכולה לשמור.13

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

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

.N/1ההסתברות להישאר עם תמונה של בית כלשהו היא מספרים. כתוב פונקציה שתסדר אותם בסדר אקראי. אתה יכול להיעזרNיש לך מערך של .14

(. 7 שמחזירה מספר אקראי )ת'כלס, בדיוק כמו שאלה Randבפונקציה

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

מיקרוסופט )חיפה( מה זה פונקציות וירטואליות? איך התוכנית יודעת להגיע לפונקציה הנכונה כשפונקציה.15

וירטואלית נקראת?, למשל(?printf )כמו Cאיך מממשים פונקציות עם מספר לא קבוע של ארגומנטים ב-.16 שני חוטים רצים במקביל. בכל אחד ישנה לולאה, ושניהם צריכים להמתין אחד לשני במקום.17

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

בלולאות הן גם זהות. אסור להשתמש בחוט נוסף. חוטים.Nאותה בעיה, רק עבור .18כתוב פונקציה אשר מקבלת מחרוזת, ומדפיסה את כל הפרמוטציות האפשריות שלה..19 , ומחזירה את האינדקס שלSet ואוסף של תווים Stringכתוב פונקציה אשר מקבלת מחרוזת .20

. הסיבוכיות שלה צריכה להיות סכום אורכיString ב-Setהמופע הראשון של תו כלשהו מ- . איזה בעיות יהיו בפונקציה אם התווים הם בקודASCIIהקלט. ניתן להניח שהתווים הם בקוד

רחב יותר, ואיך ניתן לפתור אותן? נתון לך מילון. איך תייצג אותו בצורה יעילה? תאר אלגוריתם שמקבל כקלט מילה ומוצא את כל.21

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

ביט. סט הפקודות הנדרש3 ביט. האופרנדים האפשריים הם כתובות באורך 12להיות בדיוק כולל:

4 אופרנדים כל אחת.3 פקודות שמקבלות 255.פקודות שמקבלות אופרנד אחד כל אחת 16.פקודות שלא מקבלות אופרנדים כלל

האם ניתן לבנות מעבד כזה? הסבר.א.

נסח תנאי שיבדוק האם ניתן לתכנן מעבד עבור המקרה הכללי:ב.K1 פקודות שמקבלות P1 אופרנדים באורך L1... ,K2 פקודות שמקבלות P2 אופרנדים באורך L2... ,


JobHunt.co.il

Kn פקודות שמקבלות Pn אופרנדים באורך Ln. בנים לכל היותר(. העץ לא מאוזן ולא ממויין, ויתכנו רשומות זהות2נתון עץ בינארי )לכל צומת .23

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

KLA)מגדל העמק( מה זאת מחלקה אבסטרקטית?.24איזה הבדלים קיימים בין פונקציה וירטואלית לפונקציה וירטואלית טהורה?.25 ולמה הוא חשוב?Copy Constructorמה זה .26?V-Tableלמה משמשת ה-.27 ואיך היית מממש את זה?Singletonמה זה .28?Mutexמה ההבדל בין סמאפור ל-.29איך מתבצעת תקשורת בין תהליכים ואיך מתבצעת תקשורת בין חוטים?.30

צורן )חיפה(כתוב פונקציה שמקבלת שתי מחרוזות ומשווה ביניהן..31.FIFO( עבור תור Headerכתוב ממשק של פונקציות )קובץ .32

Spectrum Dynamics)טירת הכרמל( ישנו חוואי בעל פרה אחת. כל בוקר החוואי קם, הולך לנהר, לוקח מים והולך להשקות את.33

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

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

Freescale)הרצליה( . קיימת בתוכנית פונקציה אחת]…[ = }…{int arrayנתון מערך גדול מאד שמאותחל בהצהרה: .35

שמשתמשת במערך לצורך קריאה בלבד. אפשר להגדיר את המערך כמשתנה לוקאלי בתוך (Imageהפונקציה או כמשתנה גלובאלי מחוץ לפונקציה. איך יושפעו גודל התוכנית )קובץ ה-

ומהירות הביצוע שלה בכל אחד מהמקרים? Rand, שמסודרים בצורה אקראית. לרשותך פונקציה N-1 עד 0בנה מערך של מספרים מ-.36

שמחזירה מספר אקראי. , ובכל משבצת רשום ערך כלשהו. מתחילים ממשבצת כלשהיN × Nנתונה טבלה בגודל .37

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

דרך לחשב את הסכום המקסימלי האפשרי.

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

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

אותו בדרך ולהשתמש בו אחרי זה(. קמ"ש. באיזה מהירות אתה צריך לחזור ע"מ שהמהירות40נסעת לכיוון אחד במהירות של .39

קמ"ש?80הממוצעת שלך )עבור כל הדרך( תהיה נתונים שני משתנים. איך תחליף בין הערכים שלהם בלי להשתמש במשתנה נוסף?.40 וכו'(. תאר אלגוריתםa<b, x>yנתונה טבלה של הרבה משתנים ויחסי גודל ביניהם )למשל, .41

שיאפשר לך לסדר אותם בסדר עולה.


JobHunt.co.il

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

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

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

דרך פעולה. מצא שיטה שתבטיח להם הצלחה במשימה. [ נמצאים במערך הזה, פרט לשניים,m+n+1,...,m. כל המספרים בתחום ] nנתון מערך בגודל.43

, והמערך מכיל את המספריםn=6, m=2שהם לא המינימום או המקסימום. למשל, אם . המערך לא ממוין. כיצד ניתן לגלות בשני מעברים על3,5, אז חסרים המספרים 2,4,6,7,8,9

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

(.Offב- אוOnב- נמצא מתגי לחיצה )לא ניתן לדעת האם מתג4נתון שולחן עגול מסתובב עם .44 באמצע השולחן יש מנורה, אשר המתח עבורה מחובר למפסק ראשי נפרד. בהתחלה המנורה

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

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

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

ריבועים, כשכל ריבוע הוא3 × 3תאר אלגוריתם לפתרון של סודוקו. כלומר, בהינתן טבלה של .45 בכל המשבצות, כך שכל1-9 משבצות, מצא אלגוריתם שמחשב סידור של הספרות 3 × 3

ספרה מופיעה בדיוק פעם אחת בכל ריבוע בטבלה, בכל שורה בטבלה ובכל טור בטבלה.נתון ביטוי שמכיל שלושה סוגים של סוגריים: ) (, ] [, } {..46

תאר אלגוריתם שבודק אם הביטוי הוא חוקי או לא.א.

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

ללא המשבצת הימנית התחתונה. הוכח שניתן לרצף אותו בעזרתN^2 × N^2נתון שטח בגודל .47קבוצות של משבצות מהצורה בלבד )מותר לסובב אותה(.

כתוב תוכנית הבודקת כמה ביטים דלוקים יש בבית אחד. כעת כתוב אותה כך שתתבצע בזמן.48קבוע. מהו הטרייד אוף?

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

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

שבהן יכול ספיידרמן לטפס על הבניין.מהי סיבוכיות הזמן שלה ומהי סיבוכיות הזיכרון שלה?ב.הראה שניתן לשנות את התוכנית כך שהיא תתבצע בזמן לינארי.ג..הראה שניתן לשנות את התוכנית כך שהיא תתבצע בזיכרון קבועד.

כתוב אוטומט סופי דטרמניסטי, שמקבל כקלט מספר בינארי מהספרה הגדולה ביותר לספרה.50.5הקטנה ביותר, ובודק אם המספר מתחלק ב-

כתוב תוכנית שמחפשת "לולאה" ברשימה מקושרת חד-כיוונית ומשתמשת בזיכרון בגודל קבוע..51 נתון המשחק הבא: המראיין כותב שורה של מספרים כלשהם, כשהאילוץ היחידי הוא מספר זוגי.52

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

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


JobHunt.co.il

פעולותO(1, תוך שימוש ב-)2בהינתן מספר, איך אפשר לדעת אם הוא חזקה שלמה של .53חישוב בלבד?

איך פונקצית מחלקה יודעת איזה אובייקט קרא לה? איך נבנה קוד האסמבלי של קריאה.54לפונקציה כזאת ע"מ שהיא תתבצע עם האובייקט הנכון?

. כל פיקסל מיוצג באמצעות ביט בודד. כתוב פונקציה שתחזיר אתN על Mנתונה תמונה בגודל .55תמונת הראי שלה.

.XYנתון אוסף של קטעים במערכת הצירים .56.([x0,y0( , )x1,y1])כל קטע נתון כשתי נקודות במישור:

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

צריך להיות וירטואלי?Destructor לא יכול להיות וירטואלי, ולמה Constructorלמה .57 פעולת הקצאה דינאמית מתבצעת בעזרת מערכת ההפעלה. כיצד ניתן למנוע את השימוש.58

(?A* a=new Aבמערכת ההפעלה בעת הקצאה דינאמית של אובייקט כלשהו )למשל, את מנגנון הפונקציות הוירטואליות ללא שימוש במילה השמורהCתאר שיטה ליישם ב-++.59

virtual. פעולותN½1 מספרים. מצא את המינימום והמקסימום, תוך שימוש ב-Nנתון מערך של .60

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

הריבוע המקסימלי של פיקסלים מאותו צבע. מקבלת,free עובדת כרגיל, אבל הפונקציה mallocנתונה מערכת הפעלה שבה הפונקציה .62

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

:Cלהשתמש באופן המקובל בשפת )void* MyMalloc)int sizeא.)void MyFree)void* ptrב.

'ים(. התוכנה נעזרתBuffer חוצצים )N שמשתמשת במאגר קבוע של Real-Timeנתונה תוכנת .63 – מקבלת חוצץ)buffer(FreeBuffer – מחזירה חוצץ פנוי, )(GetBufferבשתי פונקציות:

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

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

INC Rx-הגדלת הערך שב – Rx-1 ב.DEC Rx-הקטנת הערך שב – Rx-1 ב.CLR Rx-איפוס הערך שב – Rx.JUMP Rx LABEL-ביצוע קפיצה ל – LABEL-אם הערך שב Rx.שונה מאפס

. האם ניתן לוותר על חלק מהפעולות ולממש אותןR3 = R1 * R2בצע בעזרת הפעולות הנ"ל באמצעות הפעולות האחרות? האם הקוד שכתבת עובד נכון גם עבור מספרים שליליים

(?2)כלומר, כאשר מתייחסים לערכי הרגיסטרים בשיטת המשלים ל-

שאלות ששמעתי מאחרים )המשך( נמצא קודProg. ב-Data ולאזור זיכרון שנקרא Progנתון מעבד שמחובר לאזור זיכרון שנקרא .65

סיביות, וייתכן שחלקן8 הוא באמצעות קו שעוביו Data נמצאים נתונים. החיבור ל-Dataוב- ותמצא את הסיבית המנותקתProg קבוע(. כתוב פונקציה שתיצרב ב-0מנותקות )מחזירות הראשונה מביניהן.


JobHunt.co.il

. במעבד הראשון קייםxנתונים שני מעבדים עם גישה לזיכרון משותף, שמכיל משתנה בשם .66 (. בכל--x )1 ב-x(, ובמעבד השני קיים קטע קוד שמקטין את ++x )1 ב-xקטע קוד שמגדיל את n פעמים וקטע הקוד השני רץ m, קטע הקוד הראשון רץ 0 מאותחל ל-xהפעלה של המערכת,

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

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

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

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

כוס מהמיכל הראשון, מוזגים למיכל השני ומערבבים. לאחר מכן לוקחים כוס מהמיכל השני, מוזגים בחזרה למיכל הראשון ומערבבים שוב. מהו היחס בין ריכוז החלב במיכל הראשון לריכוז

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

הזה בלי שאף אחד יגלה לאחרים מהי המשכורת שלו? מטר,12 × 12 מטר. הקיר השמאלי והקיר הימני הם בגודל 30 × 12 × 12נתון חדר שגודלו .71

מטר. באמצע הקיר השמאלי ישנו שקע חשמל שנמצא מטר30 × 12ושאר הקירות הם בגודל מעל הרצפה, ובאמצע הקיר הימני ישנו שקע חשמל שנמצא מטר מתחת לתקרה. ברור שניתן

מטר ביניהם?40 מטר בין השקעים, אבל איך ניתן להעביר כבל באורך 42להעביר כבל באורך

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

איטרציותN תוך שימוש ב-N, מצא את הערך של 1 ביטים שערכם Nבהינתן מספר שבו ישנם .73לכל היותר.

30

12

12


JobHunt.co.il

סמלים בתוכנה:

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

( סמלי מאקרו, טיפוס ותבנית#define, typedef, template.נודעו לייצג ערכים קבועים כלשהם ), בערכים שנקבעו עבורם ע"י המתכנת.Preprocessingסמלים אלה מוחלפים כבר בשלב ה-

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

הקומפיילר מחלק את מרחב הזיכרון של התוכנית לשלושה אזורים בסיסיים:(.Data Sectionאזור נתונים ).1(.Code Sectionאזור קוד ).2(.Stackמחסנית ).3

( שבו היאMemory Address Spaceכשהתוכנית נכנסת למצב ריצה, היא מקבלת מרחב זיכרון קבוע )פועלת.

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

כלשהו מתחילת מרחבOffsetכלומר, כל הכתובות שאליהן התוכנית ניגשת, נמצאות למעשה ב-הזיכרון שמוקצה עבורה.

שימוש ברגיסטרים במהלך הריצה: מצביע תמיד על הפקודה הבאה לביצוע, שרשומה באזור הקוד.)PC )Program Counterרגיסטר ה- מצביע תמיד על המקום הבא שפנוי במחסנית.)SP )Stack Pointerרגיסטר ה-

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

הפנויים שברשותו.

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

הקוד.

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

שום הבדל(:משתנים גלובליים – מוכרים בכל התוכנית..1משתנים סטאטיים גלובליים – מוכרים רק בקובץ שבו הם נמצאים..2משתנים סטאטיים לוקאליים – מוכרים רק בפונקציה שבה הם נמצאים..3 המחלקה שאליה הם שייכים.Scopeמשתנים סטאטיים מחלקתיים – מוכרים רק ב-.4

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

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

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


JobHunt.co.il

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

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

שלה.

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

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

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

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

לתחילתו )במהלך הריצה של התוכנית(.

פונקציות מחלקה:

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

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

פונקציה סטאטיתפונקציה לא סטאטית

יכולה להיקרא רק ע"י אובייקט מסוג המחלקהשאליה היא שייכת

יכולה להיקרא ע"י המחלקה עצמה )וגם ע"י אובייקט, אבל אין לתוכן האובייקט שום

השפעה עליה( מקבלת בתור פרמטר גם את כתובת

האובייקט שדרכו היא נקראת )למרות שזה*מוסתר מהמתכנת(

מקבלת כפרמטרים רק את מה שמוגדרבהצהרת הפונקציה

בעלת גישה לכל השדות והפונקציות שלהמחלקה

)סטאטיים ולא סטאטיים(

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

לא יכולה להיות וירטואליתיכולה להיות וירטואלית


JobHunt.co.il

:MyClass* myPtr בעזרת המצביע ) (void MyClass::Func1קריאה לפונקציה הלא וירטואלית

Ax = myPtr//Get the address of the instanceBx = MyClass::Func1//Get the address of the function

Push Ax//Push the address of the instance into the stackPush Bx//Push the address of the function into the stack

CallF//Save some registers and jump to the beginning of the function

:MyClass* myPtr בעזרת המצביע ) (void MyClass::Func2קריאה לפונקציה הווירטואלית

Ax = myPtr//Get the address of the instanceBx = *)myPtr->__vfptr(//Get the address of the instance's V-Table

Cx = Bx + MyClass::Func2__num//Add the number of the function in its classPush Ax//Push the address of the instance into the stack

Push Cx

//Pus

h the address of the function into the stackCallF//Save some registers and jump to the beginning of the

function

כלומר, ביחס לקריאה לפונקציה לא וירטואלית, קריאה לפונקציה וירטואלית דורשת עוד מספר פעולותRead-קריאת תוכן המצביע של ה( V-Table ופעולת )Add.)אחת )בין רגיסטר למספר קבוע

תכנות מונחה עצמים:

לא מתייחס לשפת תכנות שמאפשרת דברים ששפת תכנות רגילה לא מאפשרת,OOD/OOPהמונח אלא לקונספט שמאפשר לתכנן ולממש תוכנה באופן דומה לתכנון ולמימוש של מערכות אחרות

)כאלה שאינן בהכרח קשורות לתחום(.

הקונספט הזה שם דגש על שני אלמנטים עיקריים:1.Encapsulation.)סגירות( 2.Derivation.)גזירה(

קריאה לפונקציה וירטואליתקריאה לפונקציה לא וירטואלית

הפונקציה שצריכה להתבצע ידועה כבר בזמןקומפילציה, ולכן גם כתובתה ידועה

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

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

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

כל אובייקט מקבל את הכתובת של הטבלה של המחלקה שאליה הוא שייך, כאשר הוא

נוצר )בזמן ריצה( עבור כל קריאה לפונקציה לא וירטואלית,

הקומפיילר מייצר קוד של קפיצה לכתובת שלאותה פונקציה

עבור כל קריאה לפונקציה וירטואלית, הקומפיילר מייצר קוד של קפיצה לכתובת

שרשומה בטבלה של האובייקט


JobHunt.co.il

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

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

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

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

הוא שימוש במודולים קיימים ומוכרים לצורך הרחבתם.Derivationהרעיון שעומד מאחורי :B למודול Aישנן שתי תבניות כלליות שבעזרתן ניתן להרחיב מודול

B has an, בנוסף לתכונות הספציפיות שרצויות בו )במקרה הזה, A ולשים בתוכו Bליצור את .1A.)

(.B is an A, ולהוסיף לו את התכונות הספציפיות שרצויות בו )במקרה הזה, A מ-Bלגזור את .2

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

מייצג טייפ חדשני שמאפשר גםB, ומודול Stop ו-Play מייצג טייפ שמאפשר Aלדוגמא, נניח שמודול Rewind.

כבר קיים, ובנוסף, קהל הצרכנים כבר מכיר את הממשק שלו.Aפס הייצור של .B ונוסיף לו את מימוש הממשק של A מהתחלה, נרחיב את פס הייצור של Bלכן, במקום ליצור את

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

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

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

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

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

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

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

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

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

'ים.DDLב-


JobHunt.co.il

ניהול שכבות הזיכרון:

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

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

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

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

1.Cacheזיכרון שנמצא יותר קרוב למעבד, ולכן הגישה אליו יותר מהירה. שכבה זו נקראת – .2Lלעיתים גם

2.Ramזיכרון שנמצא פחות קרוב למעבד, ולכן הגישה אליו יותר איטית. שכבה זו נקראת – .1Lלעיתים גם

(.Hard Diskמעליה נמצאת שכבת הזיכרון המשני )המעבד לא יכול לבצע את הפעולות החישוביות שלו על שכבה זו.

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

על מנת שרצף פעולות )קטע קוד( כלשהו ירוץ, הוא חייב להיטען לזיכרון הפנימי.המונח זיכרון וירטואלי מתאר צורת ניהול מתוחכמת של שכבות הזיכרון השונות.

(.MMUמיפוי כתובות הזיכרון הווירטואלי לכתובות הזיכרון הפיזי מתבצע ע"י יחידת ניהול הזיכרון )

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

השיטה היא פשוטה – ע"מ שקטע קוד כלשהו ירוץ, הדבר היחידי שחייב להיות בזיכרון הוא הפעולההבאה לביצוע:

-כאשר יש צורך בנתון כלשהו, מחפשים אותו בCache.( אם הנתון לא נמצא שםMiss-מחפשים אותו ב ,)Ram.( אם הנתון לא נמצא שםPage Fault-מחפשים אותו ב ,)Hard Disk.

"משדרגת" את המיקום שלו לפיMMUבכל שלב, במידה והנתון לא נמצא במקום המתאים, ה- (, ע"מ לשפר את זמן הגישה אליו בעתיד. דבר זה בא,Last Recently Usedיוריסטיקה כלשהי )למשל,

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

בהם.

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

ההפעלה. הגישה של כל אלה לזיכרון יכולה להתבצע בצורה "שקופה", ורק בזמן ביצוע פעולה שדורשת גישה

ובמפת הזיכרון הווירטואלי ע"מ לחשב את כתובתBase Addressלזיכרון, המעבד נעזר ברגיסטר ה-היעד המדויקת.


JobHunt.co.il

בנוסף, העובדה שעבור כל תהליך מוגדר מרחב זיכרון משלו, מאפשרת למערכת ההפעלה להגן מפני ובמפתBase Addressגישה של תהליכים אחרים לאותו מרחב זיכרון )שוב, תוך שימוש ברגיסטר ה-

הזיכרון הווירטואלי(.

ניהול תהליכים וחוטים:

( הוא למעשה תוכנית בביצוע. הגנה על תהליך מפני תהליכים אחרים מתבצעתProcessתהליך ) , שמנהלת את הזיכרון הווירטואלי. עבור כל תהליך יש רגיסטרים, שבעזרתםMMUכאמור בעזרת ה-

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

למרחב הזיכרון הפיזי של תהליך אחר.

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

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

מרחב הזיכרון של התהליך ואת המצב הנוכחי של הרגיסטרים.

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

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

התוכן הנוכחי של כל מרחב הזיכרון, אלא רק של המחסנית, מכיוון שמרחב הזיכרון משותף לכלהחוטים.

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

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

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

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


JobHunt.co.il

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

(. המנגנון שממומש, חייב גם למנוע מצב שבו קבוצה של חוטיםMutual Exclusionמניעה הדדית ) (. בנוסף, הוא גם חייבDeadlockנמצאת בהמתנה "ציקלית" לכניסה של אחד מהם לקטע הקריטי )

(.Starvationלמנוע מצב שבו חוט כלשהו ממתין לנצח להתחיל את הקטע הקריטי שלו )

שיטות לסנכרון בין חוטים:1.Busy Wait )Polling( נגדיר משתנה – Xונאתחל ,)באזור הזיכרון המשותף )משתנה גלובאלי

. בתחילת הקטע1 הוא X. כל חוט, לפני כניסה לקטע הקריטי, ימתין עד שהערך של 1אותו ל- . הבעיה היא, שחוט1, וביציאה ממנו הוא ישנה אותו בחזרה ל-0 ל-Xהקריטי, החוט ישנה את

. מצב כזה יכול לחזור0 הוא עדיין Xיכול לעבור מהמתנה לריצה רק בשביל "לגלות" שהערך של על עצמו הרבה פעמים, כשבכל פעם מתבצעת החלפת הקשר ומתבזבז זמן.

2.Semaphore נגדיר אובייקט – Semשמאפשר שתי פעולות אטומיות )פעולה אטומית היא רצף של פעולות, אשר ידוע בוודאות שבמהלכו לא מתרחשת החלפת הקשר(:

Sem.Wait) ( אם – Sem.counter-אחרת, הוצא את החוט1 גדול מאפס, הקטן אותו ב . הנוכחי להמתנה.

Sem.Signal) (אם קיים חוט שנמצא בהמתנה, הוצא אותו ממנה. אחרת, הגדל את – Sem.counter-1 ב.

Semימוקם בזיכרון המשותף, וכך יוכר ע"י כל החוטים. בנוסף, הוא ישמור רשימה של החוטים , החסימה של החוט בתחילת הקטעBusy Waitשהוא הכניס להמתנה. בניגוד לשיטת ה-

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

צורך לבצע החלפת הקשר ע"מ שקוד ההמתנה של החוט ירוץ במעבד. מוציא חוט להמתנה, הוא שהחוט קורא לפונקציה שלSem: מה שלמעשה קורה כאשר הסברSem( שבסופה מתבצעת חסימה ,Blockחסימה היא פעולה שבה חוט מבקש ממערכת .)

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

את הקטע הקריטי, מוציא מהמתנה את החוט שנמצא בה הכי הרבה זמן.3.Monitor נגדיר אובייקט – Monאשר מחזיק את "הנתונים הקריטיים" של התוכנית )אלה

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

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

ומניעתDeadlock, מניעת Mutual Exclusionלצורך יישום הסנכרון בין חוטים )שכאמור דורש, Starvation.)

1 תשובה לשאלה שלב ראשון – נעביר את כל הכדורים האדומים לתחילת המערך:

שמצביע על סוף המערך.B שמצביע על תחילת המערך ואינדקס Aנחזיק אינדקס א.

לכיוון סוף המערך, עד שניתקל בכדור שאינו אדום.Aנקדם את אינדקס ב. לכיוון תחילת המערך, עד שניתקל בכדור אדום.Bנקדם את אינדקס ג.נחליף בין הכדורים שמוצבעים ע"י האינדקסים.ד..B יעבור את אינדקס Aנחזור על שלבים ב', ג', ו-ד', עד שאינדקס ה.

שלב שני – באופן דומה, נעביר את כל הכדורים הירוקים לסוף המערך....)1(O, סיבוכיות זיכרון – )O)nסיבוכיות זמן –

2 תשובה לשאלה על מנת להפוך רשימה מקושרת חד-כיוונית:

void Node::Swap)Node* pNext({

if )pNext!=NULL(


JobHunt.co.il

{pNext->Swap)pNext->m_pNext(;

pNext->m_pNext=this;}

}

void List::Reverse)({

if )m_pHead!=NULL({

m_pHead->Swap)m_pHead->GetNext)((;m_pHead->SetNext)NULL(;

}Node* pTemp=m_pHead;

m_pHead=m_pTail;m_pTail=pTemp;

}על מנת להפוך רשימה מקושרת דו-כיוונית:

void Node::Swap)({

if )m_pNext!=NULL({

m_pNext->Swap;)(m_pNext->m_pNext=this;

}m_pPrev=m_pNext;

}

void List::Reverse)({

if )m_pHead!=NULL({

m_pHead->Swap;)(m_pHead->SetNext)NULL(;

}Node* pTemp=m_pHead;

m_pHead=m_pTail;m_pTail=pTemp;

}

3 תשובה לשאלה אחרי הכניסהB לפני הכניסה לאולם וגלאי Aנשתמש בשני גלאים שמונחים בצורה טורית: גלאי

לאולם..0, שיאותחל ל-fעבור כל גלאי נחזיק משתנה בוליאני

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

אםf)B(=0 אז התנועה היא כלפי פנים. נאתחל את ,f)A(-1 ל. אםf)B(=1 מהמונה, ונאפס את 1, אז התנועה היא כלפי חוץ. נחסיר f)A( ואת f)B(.

מזהה תנועה:Bכאשר אםf)A(=0 אז התנועה היא כלפי חוץ. נאתחל את ,f)B(-1 ל. אםf)A(=1 למונה, ונאפס את 1, אז התנועה היא כלפי פנים. נוסיף f)A( ואת f)B(.

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


JobHunt.co.il

4 תשובה לשאלה לא קיים.Task, אז ה-Taskאם הזמן הנוכחי לא נמצא בין זמן ההתחלה לזמן הסיום של ה-:Taskאם הזמן הנוכחי כן נמצא בין זמן ההתחלה לזמן הסיום של ה-

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

, אז הוא נמצא בריצה. אחרת, הואTaskאם השארית שקיבלנו היא קטנה מאורך זמן הריצה של ה-נמצא בהמתנה.

STATE Task::GetState)iCurrentTime({

if )m_iBeginTime<=iCurrentTime && iCurrentTime<=m_iEndTime({

int iModulo=)iCurrentTime-m_iBeginTime(%)m_iRunTime+m_iPendTime(;if )iModulo<iRunTime(

return RUNNING;else

return PENDING;}

elsereturn NOT_ALIVE;

}.Runningתמיד מתחיל ב-Task ההנחה היא כמובן, שה-

בתנאיiModulo<iRunTime, אז צריך להחליף את התנאי Pendingאם הוא מתחיל ב-iModulo>=iPendTime.

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

משתנה סטאטי שסופר אותם. שלה צריךDestructor, וב-1 של המחלקה צריך להגדיל את המשתנה הזה ב-Constructorבכל

.1להקטין אותו ב-

6 תשובה לשאלה

Running Pending Running Pending Running Pending

Begin Time End TimeCurrent Time


JobHunt.co.il

יכול להופיע ברמת הפונקציה )משתנה לוקאלי( וברמת הקובץ )משתנהCמשתנה סטאטי ב- שבו הקומפיילר מזהה אותו. בכל מקרה, המשתנה ימוקם ב-Scopeגלובאלי(. ההבדל הוא רק ב-

Data Section. שבוScope יכול להופיע גם ברמת המחלקה. גם כאן ההבדל הוא רק ב-Cמשתנה סטאטי ב-++

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

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

יכולה להופיע גם ברמת המחלקה )פונקציה מחלקתית(, והיא למעשהCפונקציה סטאטית ב-++כמו פונקציה גלובאלית, למעט העובדה שאפשר לפנות אליה רק דרך המחלקה – )

MyClass::Func…(בניגוד לפונקציות מחלקה שאינן סטאטיות, היא לא מקבלת מצביע לאובייקט . "(, ולכן לא יכולה לגשת לשדות לא סטאטיים או לפונקציות לאthisמסוג המחלקה )אין לה "

סטאטיות של המחלקה בלי שיש ברשותה אובייקט מתאים. )חומר כללי: סמלים בתוכנה(.3לפירוט נוסף – חלק

7 תשובה לשאלה איטרציות.Nנבצע

:iבאיטרציה מספר השירים הראשונים.N-iברשימת הקלט, נבחר שיר אקראי מתוך א..iברשימת הפלט, נכניס אותו למקום ה-ב. (, ע"מ שלא נוכל לבחור אותוN-iברשימת הקלט, נחליף בינו לבין השיר שנמצא במקום ה-)ג.

באיטרציה הבאה.

void RandReorder)Song* inputArray]N[, Song* outputArray]N[({

for )int i=0; i<N; i++({

int index = Rand)(%)N-i(;outputArray]i[ = inputArray]index[;

Swap)inputArray,index,N-1-i(;}

}שיטה נוספת:

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

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

איטרציות. .index = )index + P( % Nאת ההתקדמות נבצע בצורה ציקלית: ג. לפי חוק הציקליות בחבורות )או משהו כזה(, אנחנו נעבור כל שיר פעם אחת בדיוק לפני שנחזורד.

לשיר הראשון.בעיות אפשריות:

זמן חישוב הרשימה החלקית עלול להיות ארוך )למרות שזה לא עקרוני, כי מחשבים אותה רק.1פעם אחת(.

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

כלל. הסיבה לכך היא: > מספר הסידורים השונים שאנחנו יכולים לקבל בשיטה הזאת = גודל הרשימה החלקיתN. מספר הסידורים השונים האפשרי עבורN = 2 * 1 שירים * … * N = N.עצרת


JobHunt.co.il

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

אפשרויות: של המחלקה. ניתן יהיה ליצור עצמים של מחלקותprotected ב-Constructorלשים את ה-.1

שיורשות ממנה. של המחלקה, ולהוסיף פונקציה סטאטית שיוצרת עצםprivate ב-Constructorלשים את ה-.2

(.Singletonמהסוג שלה ומחזירה מצביע אליו )בשיטת ה-

9 תשובה לשאלה המנורות שיישארו דולקות: אלה שמספר המחלקים של האינדקס שלהן הוא אי זוגי.

...25, 16, 9, 4, 1האינדקסים שמספר המחלקים שלהם הוא אי זוגי: מספרים ריבועיים –

10 תשובה לשאלה אם לא ידוע מי מתחיל, אז אין שיטה כזאת, כי זה פרדוקס )אם הייתה שיטה כזאת, יש סיכוי

שהשחקן השני היה משתמש בה ומנצח – סתירה(.השחקן הראשון שמתחיל יכול לנצח:

את המטבע הראשון הוא צריך לשים במרכז השולחן.א.

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

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

נחשב את ההסתברויות הבאות:A = 1/2 = ההסתברות לגשת לסל הראשוןB = 1/1 = ההסתברות להוציא כדור אדום מהסל הראשוןC = 1/2 = ההסתברות לגשת לסל השניD = 9/19 = ההסתברות להוציא כדור אדום מהסל השני

נקבל את התוצאה:A*B+C*D = 14/19 = ההסתברות להוציא כדור אדום

12 תשובה לשאלה .14את הכדור הראשון נזרוק מקומה

)או עד שהוא יישבר(.13 עד לקומה 1אם הוא נשבר, ננסה את הכדור השני מקומה (.1-13, 14 ניסיונות )14סה"כ במקרה הגרוע –

.27אם הכדור הראשון לא נשבר, נזרוק אותו מקומה )או עד שהוא יישבר(.26 עד לקומה 15אם הוא נשבר, ננסה את הכדור השני מקומה

(.15-26, 27, 14 ניסיונות )14סה"כ במקרה הגרוע – ,14נמשיך באותו אופן, כשבכל פעם אנחנו עולים קומה אחת פחות ממה שעלינו בפעם הקודמת )

.14( ולכן מספר הניסיונות במקרה הגרוע יישאר 99, 95, 90, 84, 77, 69, 60, 50, 39, 27 . סה"כ –100 ניסיונות( הכדור הראשון עדיין לא נשבר, נזרוק אותו מקומה 11 )לאחר 99אם בקומה

נסיונות.12 נסיונות.14לסיכום, לכל היותר נבצע

13 תשובה לשאלה נצלם תמיד )כדי שבכל מקרה תהיה לנו תמונה, אם אין אחריו עוד בית(.1את בית מספר .Rand)(%2, תוך שימוש בפונקציה 1/2 נצלם בהסתברות 2את בית מספר .Rand)(%3, תוך שימוש בפונקציה 1/3 נצלם בהסתברות 3את בית מספר .Rand)(%X, תוך שימוש בפונקציה X/1 נצלם בהסתברות Xאת בית מספר


JobHunt.co.il

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

.100% מתקבל בהסתברות של 1, בית מספר N=1עבור .1 , ולכן ההסתברות של בית מספר50% מתקבל בהסתברות של 2, בית מספר N=2עבור .2

.50% יורדת ל-1:N=k+1 ונוכיח עבור N=kנניח נכונות עבור .3

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

1את בית מספר+k 1 נצלם בהסתברות(/k+1)ולכן ההסתברות שתישאר בידינו , .)k/)k+1, כלומר (k+1/)1-1 הבתים הקודמים היא kתמונה של אחד מ-

-מכיוון שההסתברות לתמונה של כל אחד מkהבתים היא עדיין שווה, נקבל .(k+1/)1, כלומר k[/)k/)k+1] הבתים היא kשההסתברות לתמונה של כל בית מתוך

מסקנה – ההסתברות של בית מספרk+1 שווה להסתברות של כל בית מתוך k .(k+1/)1הבתים:

14 תשובה לשאלה .7אותו עקרון כמו בתשובה לשאלה

15 תשובה לשאלה .C ב-++Polymorphismפונקציות וירטואליות זהו הכלי שבעזרתו )ובעזרת הורשה( ניתן לייצר

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

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

כל אובייקט מקבל את הכתובת של הטבלה של המחלקה שאליה הוא שייך, כאשר הוא נוצר )בזמןריצה(.

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

)חומר כללי: פונקציות מחלקה(.3לפירוט נוסף – חלק

16 תשובה לשאלה עבור הארגומנטים שהפונקציה מקבלת(.Default, אפשר להשתמש בערכי C )ב-++Cשימושי ב-

.)… ,void func)int xהחתימה של הפונקציה נראית כך: הערך המוחזר יכול להיות מכל סוג שהוא, וחייב להיות לפחות ארגומנט אחד מוצהר.

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

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

.בודקים את הכתובת של הארגומנט המוצהר האחרון בתים אחריו, וכך גם לגבי כל ארגומנט נוסף שנשלח8 או 4הארגומנט הבא ממוקם

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

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

את הערכים עצמם.


JobHunt.co.il

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

לדוגמא, עבור הקריאה הזאת לפונקציה:short y=1000;

int sum=func)1,y,5000,"abc"(;נממש את הפונקציה כך:

int func)char x, …({

short y = )short())int*(&x+1(]0[;//y = 1000int z = )int ())int*(&x+2(]0[;//z = 5000char* s= )char*())int*(&x+3(]0[;//s = "abc"

return x+y+z+s]0[;//1+1000+5000+'a' = 6098}

)מוגדריםva_list, va_start, va_end, va_argאפשר לממש את זה בצורה יותר נוחה בעזרת (.stdarg.hבקובץ

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

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

היא מניחה שמספר הארגומנטים שנשלחו אליה הוא מספר הפעמים שהתו '%' מופיע במחרוזת.

'%'-היא מנחשת מהו הסוג של כל ארגומנט לפי האות שמופיעה ליד כל אחד מתווי ה במחרוזת.

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

שנשלח שונה מהגודל שהיא מניחה שהוא, היא "יוצאת מסינכרון" לגביו ולגבי כל שאר בתים(.8 בתים או 4הארגומנטים שבאים אחריו )הגודל יכול להיות

דוגמאות: :)printf)"%d %d",5. הרצה של 1

.)הפונקציה ניגשת לאזור שלא הוגדר עבורה בזיכרון וקוראת "זבל" )או מפילה את התוכנית :)printf)"%d %f",1.2,3.4. הרצה של 2

בתים ובפורמט 8הפונקציה מקבלת שני ארגומנטים בגודל Floating-Point.כל אחד -הבתים הראשונים היא קוראת מספר בפורמט 4מ Fixed-Point.-הבתים הבאים היא קוראת מספר בפורמט 8מ Floating-Point.-בתים האחרונים היא מתעלמת.4מ

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

בדוגמאות הנ"ל(. התוצאה – שגיאות בזמן ריצה.

17 תשובה לשאלה בכל חוט באופן הבא:Busy Wait ונבצע עליו 0, נאתחל אותו ל-xנגדיר משתנה גלובאלי

if )x==0({

x=1;while )x==1(} {

}else

x=0;


JobHunt.co.il

וימתין עד שהוא יחזור1, ישנה אותו ל-0 שווה ל-xהחוט הראשון שיגיע ללולאה בכל פעם, יגלה ש-.0להיות

. בשלב זה, שני החוטים0 וישנה אותו ל-1 שווה ל-xהחוט השני שיגיע ללולאה בכל פעם, יגלה ש-ימשיכו לרוץ.

הערות: הוא בזבזני מבחינת זמן, מכיוון שבזמן שהחוט הראשון שהגיעBusy Waitהשימוש ב-.1

ללולאה ממתין שהחוט השני יגיע אליה, עלולות להתבצע החלפות הקשר רק לצורך בדיקת )בקוד של החוט הראשון(.xהערך של

[ חייבת להיות מוגדרת כפעולהx , שינוי הערך של xסדרת הפעולות ]בדיקת הערך של .2אטומית אחת, אשר במהלכה לא יכולה להתבצע החלפת הקשר.

19 תשובה לשאלה .]S]1…n תווים באופן הבא: nנסמן מחרוזת באורך של

ומחזירה את רשימת כל הפרמוטציות]S]1…nנממש פונקציה רקורסיבית, שמקבלת מחרוזת שלה:.)תנאי העצירה: כאשר מחרוזת הקלט ריקה, נחזיר רשימה שבה מחרוזת אחת )ריקה צעד רקורסיה מספרx:

, ע"מ לקבל את רשימת כל הפרמוטציות]S]x+1…nנקרא לפונקציה עם תת המחרוזת .1שלה.

תווים.n-x מחרוזות, כל אחת באורך של (!n-x)נקבל רשימה באורך של .2 בכל מקום אפשרי.)S)xנעבור על הרשימה, ולכל מחרוזת נוסיף את התו .3.)S)x מקומות אפשריים להוסיף את התו n-x+1לכל מחרוזת יש לנו .4 תווים.n-x+1 מחרוזות, כל אחת באורך של (!n-x+1)נקבל רשימה חדשה באורך של .5

List Permute)String string({

if )string.length == 0(return List)1(;

List prevList = Permute)SubString)string,1,string.length((;List nextList = List)string.length*prevList.length(;

for )int m=0; m<prevList.length; m++({

for )int n=0; n<string.length; n++({

nextList]m*string.length+n[ += SubString)prevList]m[,0,n(;nextList]m*string.length+n[ += string]0[;

nextList]m*string.length+n[ += SubString)prevList]m[,n,string.length-1(;}

}return nextList;

}

20 תשובה לשאלה (.ASCII תאים )כמספר התווים בקוד 256ניעזר במערך בוליאני שגודלו


JobHunt.co.il

במקום המתאים לו במערך.true, ועבור כל תו נרשום Setנעבור על אוסף התווים .true, ונחפש את התו הראשון אשר במקום המתאים לו במערך רשום Stringנעבור על המחרוזת

ברגע שנמצא תו כזה, נחזיר את האינדקס שלו.int FirstIndex)const char* string, const char* set(

{bool array]256[=}false{;

for )int i=0; i<strlen)set(; i++(array]set]i[[=true;

for )int j=0; j<strlen)string(; j++(if )array]string]j[[==true(

return j;return -1;

}סיבוכיות הזמן שווה לסכום אורכי הקלט. סיבוכיות הזיכרון היא כמספר התווים האפשריים.

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

Hashing.)ישיר כזאת, נצטרך יותרHash Tableסביר להניח שכדי למצוא את המקום המתאים לתו כלשהו ב-

מפעולה אחת. בעזרת מספרHashingעל מנת להשיג את אותה סיבוכיות, נצטרך לממש טבלה שמאפשרת

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

לפי הסדר, ועבור כל תו לבדוק אם הוא נמצאStringאפשרות נוספת: פשוט לעבור על התווים ב-.Setב-

במקרה הזה לא נצטרך זיכרון נוסף בכלל, אבל סיבוכיות הזמן תגדל מסכום אורכי הקלט למכפלתאורכי הקלט.

21 תשובה לשאלה , שכל תא בה מייצג את האותHash Tableע"מ לייצג את המילון בצורה יעילה אפשר להשתמש ב-

הראשונה במילה. , שכל תא בה מייצג את האות השנייה במילה, וכן הלאה באופןHash Tableבנוסף, בכל תא תהיה

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

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

Hash Table.שנממש .Hash Tableסיבוכיות הזיכרון של המילון תלויה גם היא בסוג ה-

ישירה )מערך(, סיבוכיות הזמן תהיה לינארית באורך הקלט.Hash Tableלדוגמא, אם נשתמש ב- לעומת זאת, סיבוכיות הזיכרון תהיה מאד בזבזנית, מכיוון שמבנה המילון יאפשר קיום של כל

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

, ונבדוק עבור כל פרמוטציה שהפונקציה19נשתמש בפונקציה שתוארה בתשובה לשאלה .1 מחזירה אם היא נמצאת במילון. הבעיה היא, שנצטרך לעבור על כל הפרמוטציות האפשריות

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

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

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


JobHunt.co.il

22 תשובה לשאלה ביטים.3. כאמור, כל אופרנד הוא באורך 2^12 = 4096 רצפים אפשריים: 4096ישנם סה"כ

.4 * 2(^3*3 = )2048 רצפים שונים: 2048 אופרנדים, דרושים לנו 3 פקודות שמקבלות 4עבור *2(^1*3 = )2040 רצפים שונים: 2040 פקודות שמקבלות אופרנד אחד, דרושים לנו 255עבור

255..16 * 2(^0*3 = )16 רצפים שונים: 16 פקודות שלא מקבלות אופרנדים כלל, דרושים לנו 16עבור

רצפים שונים – יותר ממספר הרצפים האפשריים, ולכן לא ניתן לבנות4104סה"כ דרושים לנו מעבד כזה.

צריך להיות קטן ממספר הרצפים[)Ki * 2^)Pi*Li∑]תנאי עבור המקרה הכללי: הסכום האפשריים.

23 תשובה לשאלה קידוד העץ לקובץ:

)אב, בן שמאלי, בן ימני(, ולכל צומת ניתן מספר סידוריPre-Orderנעבור על העץ בשיטת .1עולה.

נרשום בקובץ את מספר הצמתים שיש בעץ..2נקצה מערך של מצביעים ונעבור על העץ שוב..3לכל צומת, נרשום בתא שמספרו הוא המספר הסידורי של הצומת את הכתובת של הצומת..4נעבור על המערך לפי הסדר, ולכל צומת נרשום בקובץ את תוכן הרשומה שלו..5נעבור על המערך שוב, ולכל צומת נרשום בקובץ את המספרים הסידוריים של שני הבנים שלו..6

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

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

הצומת במערך. נעבור על המערך לפי הסדר, לכל צומת נקרא מהקובץ זוג מספרים, ונקשר את הצומת.3

לאיברים המתאימים במערך. , כתובתו של השורש תהיה במקום הראשוןPre-Orderהערה – מכיוון שקודדנו את העץ בשיטת

במערך.

24 תשובה לשאלה מחלקה אבסטרקטית זאת מחלקה שיש בה פונקציה וירטואלית טהורה, ולכן אי אפשר ליצור

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

25 תשובה לשאלה פונקציה וירטואלית:

במחלקה שבה היא מוגדרת – חייבים לממש אם רוצים לאפשר יצירה של עצמים מסוגה.א.

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

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

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

26 תשובה לשאלה של מחלקה כלשהי לא מוגדר באופן מפורש ע"י המתכנת, אזCopy Constructorאם ה-

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


JobHunt.co.il

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

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

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

קריאה לפונקציה כלשהי מתורגמת לפקודת קפיצה לכתובת, שבה תימצא הפקודה הראשונה של הפונקציה.

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

האובייקט רק אם מדובר בעצם "ממשי" )ולא במצביע(. במקרה כזה הוא לא יכול לתרגם את:V-Tableהקריאה לפונקציה לפקודת קפיצה לכתובת. הפתרון –

עבור כל מחלקה, הקומפיילר מייצר טבלה שבה רשומות כתובות הפונקציות הווירטואליות , והיא נועדה ע"מ לאפשר קריאהV-Tableשל המחלקה בזיכרון. טבלה כזאת נקראת

לפונקציות הווירטואליות האלה באמצעות מצביע.-כמו כן, הקומפיילר מוסיף לרשימת השדות של כל מחלקה מצביע לV-Table.עבור כל קריאה לפונקציה וירטואלית באמצעות מצביע, הקומפיילר מקודד מספר פקודות

של האובייקט, שבאמצעותו נקראהV-Tableמכונה, שבסופן קפיצה לכתובת שרשומה ב-הפונקציה.

-כל אובייקט מקבל את הכתובת של הV-Tableהמתאים לסוג שלו, רק כאשר הוא נוצר )בזמן ריצה(. )חומר כללי: פונקציות מחלקה(.3לפירוט נוסף – חלק

28 תשובה לשאלה Singleton זה Design Pattern:של מחלקה, שמאפשר ליצור רק עצם יחיד מסוגה בכל המערכת

נגדיר מחלקה בשםMyClass-ונשים את ה ,Constructor-שלה ב private. כך אי אפשר ליצורInstanceשלה בצורה מפורשת, וגם לא לרשת אותה )וליצור עצם

שנגזר ממנה(. ,נגדיר בתוך המחלקה משתנה סטאטי שיצביע לעצם היחיד מהסוג שלהMyClass*

m_pInstance. :נאתחל אותוMyClass* MyClass::m_pInstance = NULL.נגדיר בתוך המחלקה פונקציה סטאטית שתיצור עצם חדש רק אם המצביע הוא עדיין

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

MyClass* MyClass::CreateInstance)({

if )m_pInstance == NULL(m_pInstance = new MyClass;)…(

return m_pInstance;}

29 תשובה לשאלה זה סוג ספציפי של סמאפור:Mutexסמאפור זה מושג כללי, ו-

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


JobHunt.co.il

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

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

הוא סמאפור שמספר החוטיםMutexחוט נוסף שמנסה להשתמש בו נכנס להמתנה. שיכולים להשתמש בו לפני שהוא ננעל הוא אחד.

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

30 תשובה לשאלה תקשורת בין תהליכים:

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

על מנת לקיים תקשורת בין תהליכים יש צורך במשאבים של מערכת ההפעלה, כמוPipe .Message Boxאו

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

התוכנית.מכיוון שכל החוטים שייכים לאותו התהליך )ולמעשה לאותה התוכנית(, הם חולקים את

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

גלובאליים )משתנים, סמאפורים וכו'(, אשר לכל החוטים יש גישה אליהם. )חומר כללי: ניהול תהליכים וחוטים(.3לפירוט נוסף – חלק

31 תשובה לשאלה bool strcmp)const char* str1, const char* str2(

{for )int i=0; str1]i[!=0 && str2]i[!=0; i++(

if )str1]i[ != str2]i[(return false;

return str1]i[ == str2]i[;}

32 תשובה לשאלה void InitQueue)Queue* pQueue, int iSize(;

bool Insert)Queue* pQueue, const Item* pItem(;bool Extract)Queue* pQueue, Item** pItem(;

bool GetFirst)const Queue* pQueue, Item** pItem(;


JobHunt.co.il

bool IsFull)const Queue* pQueue(;bool IsEmpty)const Queue* pQueue(;

33 תשובה לשאלה נניח שהנהר, החוואי והפרה ממוקמים באופן הבא:

-גדת הנהר שקרובה לחוואי ולפרה – על ציר הX. החוואי – בנקודה(0,a)-שנמצאת בחלק החיובי של ציר ה ,Y. הפרה – בנקודה(b,c) שנמצאת ברבע החיובי של מערכת הצירים ,XY.

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

+ )f)x( = √)x²+a²לכן, אפשר לתאר את המרחק שהחוואי צריך ללכת כפונקציה של הנקודה הנ"ל: √))b-x(²+c²(.

על מנת למצוא את המרחק המינימלי שהחוואי צריך ללכת, אפשר לגזור את הפונקציה ולהשוותאת הנגזרת לאפס.

שבו היאxהבעיה היא שהנגזרת של הפונקציה היא די מסובכת, וקשה למצוא את הערך של מתאפסת.

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

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

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

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

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

הצורה או מחוץ לצורה. . נבחר נקודה על הישר שנמצאת מחוץ לצורה )נקודהXנעביר דרך הנקודה ישר שמקביל לציר ה-

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

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

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

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

1 2 3


JobHunt.co.il

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

ותיטען לזיכרוןData Sectionאם המערך יוגדר מחוץ לפונקציה, אז רשימת הערכים שלו תשב ב- ביחד עם קוד התוכנית. כלומר, הקוד לא יכלול את פקודות ההשמה ולכן גודל התוכנית יהיה קטן

יותר. בנוסף, הפונקציה לא תאתחל את המערך בכל פעם שהיא תיקרא, ולכן גם תרוץ מהר יותר.

36 תשובה לשאלה איטרציות.N )לפי הסדר(, ונבצע N-1 עד 0נמלא מערך במספרים

לאיבר שיושבi, ונחליף בין האיבר שיושב במקום ה-j נחשב מספר אקראי iבאיטרציה מספר :jבמקום ה-

for )i=0; i<N; i++(array]i[ = i;

for )i=0; i<N; i++(Swap)array,i,Rand)(%N(;

37 תשובה לשאלה נשתמש בטבלת עזר )תכנון דינאמי( – בכל משבצת בטבלת העזר נרשום את הסכום הכי גדול של

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

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

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

הערך המתאים באופן הבא:

.לסיום, נעבור על השורה האחרונה בטבלת העזר ונמצא את הסכום הכי גדול שרשום בה.)N^2(O, סיבוכיות זיכרון – )O)N^2סיבוכיות זמן –

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

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

4 12 2 7

6 1 10 9

8 7 10 4

6 8 5 11

הטבלה המקורית

13

4 12 2 7

5 3

13

טבלת העזר


JobHunt.co.il

39 תשובה לשאלה נסמן:S.מרחק הנסיעה כולה – V.מהירות הנסיעה הממוצעת – T1.זמן הנסיעה בכיוון הלוך – T2.זמן הנסיעה בכיוון חזור –

ידוע לנו:T1 = ½S / 40)נתון(V = S / )T1+T2()מהירות שווה מרחק חלקי זמן(

ולכן נובע:T2 = S / V - ½S / 40

אם נרצה שיתקיים:V = 80

אז נצטרך שיתקיים:T2 = S / 80 - ½S / 40 = 0

וזה בלתי אפשרי )לנסוע חזרה ב"אפס זמן"(.

40 תשובה לשאלה . נבצע את פעולות ההשמהB והמספר השני נתון ברגיסטר Aנניח שמספר אחד נתון ברגיסטר

הבאות לפי הסדר:A = A + BB = A – BA = A – B

41 תשובה לשאלה , אםY ו-Xנבנה לפי הטבלה גרף, שבו כל צומת מייצג משתנה כלשהו, ולכל שני צמתים שמייצגים

Y>X-אז יש קשת מ X-ל Y כמובן שלא יכולים להיות מעגלים, כי לא יכול להיות מצב שבו .>…X>Z>Y>X.

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

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

42 תשובה לשאלה , וקובעים ביניהם מה כל אסיר צריך לעשות כשהואN ל-1האסירים מחלקים לעצמם מספרים בין

יוצא החוצה.בנוסף, לפני שהמנהל מחזיר אותם לתאים, הם דואגים שהנורה תהיה כבויה.

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

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

43 תשובה לשאלה


JobHunt.co.il

אפשר לגלות מי הם שני המספרים החסרים, גם אם אחד מהם הוא המינימום או אחד מהם הואהמקסימום )או גם וגם(.

בנוסף, אפשר לעשות את זה במעבר אחד על המערך )אז אולי חסרים תנאים מגבילים בשאלההזאת(:

S0נעבור על המערך ונחשב את סכום האיברים שלו ואת מכפלת האיברים שלו )נסמן .1

בהתאמה(.P0ו-] ידועים, ניתן לחשב את הסכום ואת המכפלה של כל המספרים בתחום n ו-mמכיוון ש-.2

m,…,m+n+1]. ו-Sנחשב את סכום שני האיברים שחסרים ואת מכפלת שני האיברים שחסרים )נסמן .3

P:)בהתאמה S = ∑]m,…,m+n+1[ – S0 , P = ∏]m,…,m+n+1[ – P0.

.x1 * x2 = P וגם x1 + x2 = S. מתקיים: x1,x2נסמן את שני המספרים שחסרים .4-x1,x2 = ]-S ± √)S²קיבלנו שתי משוואות בשני נעלמים, ומכאן הפתרון הוא פשוט: .5

4P([ / -2. (.1הערה: עברנו על המערך בסך הכל פעם אחת בלבד )בשלב מספר

44 תשובה לשאלה מצבים16(, ישנם סה"כ Off או On מצבים )2 מתגים שכל אחד מהם נמצא באחד מ-4מכיוון שיש

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

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

לכן:.בכל שלב אי-זוגי, לאחר סיבוב השולחן, נלחץ על המתג שמימיננו ועל המתג שלידנו.בכל שלב זוגי, לאחר סיבוב השולחן, נלחץ על המתג שמימיננו ועל המתג שמשמאלנו

: 2לדוגמא, נניח שאנחנו יושבים בכסא מספר 2 ועל המתג שנמצא ליד כסא מספר 1פעם אחת נלחץ על המתג שנמצא ליד כסא מספר. 3 ועל המתג שנמצא ליד כסא מספר 1פעם שניה נלחץ על המתג שנמצא ליד כסא מספר.

בשיטה הזאת מובטח לנו, שבכל שלב לפחות מתג אחד ישנה את מצבו. ,Off או כולם ב-Onעל מנת להוכיח, שמכל מצב התחלתי של המתגים מגיעים למצב שבו כולם ב-

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

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

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

המצבים הבאים האפשריים לאחר4טבלה א': בכל שורה נרשום מצב כלשהו, ומולו את שלב אי-זוגי.

המצבים הבאים האפשריים לאחר4טבלה ב': בכל שורה נרשום מצב כלשהו, ומולו את שלב זוגי.

תיקון לתשובה )נשלח ע"י גולש באתר(:

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

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

1

24

3


JobHunt.co.il

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

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

1 שלב

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

ועכשיו כולם דלוקים.

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

( כמו שהם היו.3( ו )2( או שהשאיר את מצב )1, או שפתר את הבעיה )אם המצב היה אכן 1שביצענו בשלב

2 שלב

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

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

( נשאר3( משאיר נורה אחת שונה מהאחרים – מצב )3נשים לב ששינוי שני מתגים אחד ליד השני במצב )(.3במצב )

3 שלב

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

. לפי הצורך2ו

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

לפי הסדר:9 עד 1בכל שורה נתחיל במשבצת אחרת, ונמלא את המספרים 1 נתחיל במשבצת מספר 1בשורה מספר. 4 נתחיל במשבצת מספר 2בשורה מספר. 7 נתחיל במשבצת מספר 3בשורה מספר. 2 נתחיל במשבצת מספר 4בשורה מספר. 5 נתחיל במשבצת מספר 5בשורה מספר. 8 נתחיל במשבצת מספר 6בשורה מספר. 3 נתחיל במשבצת מספר 7בשורה מספר. 6 נתחיל במשבצת מספר 8בשורה מספר. 9 נתחיל במשבצת מספר 9בשורה מספר.

משבצות )טווח הערכים שלהם9 × 9 כאינדקסים לטבלה של j ו-iעבור המקרה הכללי, נשתמש ב-(.0יתחיל מ-

.Table]i[]j[ = ) ) i * 6 - i / 3 + j ( % 9 ( + 1נקבל את הנוסחא:

46 תשובה לשאלה קיימים שלושה סוגים של סוגריים: ) (, ] [, } {.

נחלק את הסוגים השונים לשתי קבוצות:סוגרים שמאליים הם כאלה שמתחילים סוגריים: (, [, {..1


JobHunt.co.il

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

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

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

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

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

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

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

47 תשובה לשאלה ללא המשבצת הימנית התחתונה, וניתן לרצף אותו באמצעות2×2, נקבל שטח בגודל N=1עבור

הצורה:

ללא המשבצת הימנית התחתונה, וניתן לרצף אותו באמצעות4×4, נקבל שטח בגודל N=2עבור הצורות:

.N=k ללא המשבצת הימנית התחתונה, עבור N^2 × N^2נניח שניתן לרצף שטח בגודל :N=k+1 ללא המשבצת הימנית התחתונה, עבור N^2 × N^2נוכיח שניתן לרצף שטח בגודל

לפי ההנחה, ניתן לרצף שטח בגודלk^2 × k^2.ללא המשבצת הימנית התחתונה :ניקח את השטח הזה, נשכפל אותו ארבע פעמים, ונמקם כל חלק באופן הבא

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

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

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

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

באמצעות הצורה: ביחד עם החלק הרביעי, נקבל שטח בגודל(k+1)^2 × )k+1(^2ללא המשבצת הימנית

התחתונה.:N=3, שטח עבור N=2לדוגמא, נבנה באמצעות השטח שקיבלנו עבור

1 2

3 4


JobHunt.co.il

ללא המשבצת הימניתn^2 × n^2חישוב מספר הצורות שבהן נשתמש בשביל לרצף שטח בגודל התחתונה:

A1 = 1An+1 = 4An+1

48 תשובה לשאלה int func)byte x(

{int res = 0;

for )int i=0; i<sizeof)x(*8; i++(res += )x>>i(&1;

return res;}

עבור כל הערכיםHash Table, אפשר להכין מראש O(1על מנת שהפונקציה תתבצע בזמן קבוע )האפשריים של בית אחד. הטרייד אוף יהיה בצריכת הזיכרון.

49 תשובה לשאלה int Count)int num(

{if )num<3(

return num;return Count)num-1(+Count)num-2(;

} קומות.n תחזיר את מספר האפשרויות השונות לטיפוס על בניין בן )Count)nקריאה ל-

, כי זה מספר הפעמים שהפונקציה נקראת.)O)2^nסיבוכיות הזמן היא אקספוננציאלית – סיבוכיות הזיכרון היא אקספוננציאלית, כי כל קריאה לפונקציה דורשת מקום נוסף במחסנית )שגם

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

int Count)int num({

int prev = 1;int curr = 1;

for )int i=1; i<num; i++({

int next = prev + curr;prev = curr;curr = next;

}


JobHunt.co.il

return curr;}

.)1(O, וסיבוכיות הזיכרון היא קבועה – )O)nבפתרון הזה, סיבוכיות הזמן היא לינארית –

50 תשובה לשאלה מצבים.5סה"כ

" הוא המצב ההתחלתי.0מצב "שארית .ACCEPT" הוא גם ה-0מצב "שארית

( מגיעים אליו.10 מתוך 2חמישית מהחיצים ).REJECTכל שאר המצבים שקולים ל-

(, מתבצע:1 או 0עבור כל קלט )NextState = )2 * CurrState + Input( % 5

51 תשובה לשאלה , שאחריוAעל מנת לדעת אם קיימת "לולאה" ברשימה מקושרת חד-כיוונית, מספיק למצוא צומת

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

הרשימה(, ונחפש אותם באופן הבא: מובילה אליו.Nלכל צומת בקטע הצמתים שהגדרנו, נבדוק אם הקשת מצומת .1אם נמצא צומת כזה, נדע בוודאות שקיימת "לולאה" ברשימה..2, מובילה לצומת כלשהו.Nאם לא, נבדוק אם הקשת מצומת .3אם לא, נדע בוודאות שלא קיימת "לולאה" ברשימה )כי הגענו לסופה(..4 ונחזור על התהליך שוב.Nאם כן, נרחיב את הקטע לצומת הבא אחרי צומת .5

bool SearchLoop)List* list({

for )Node* tail = list->head; tail != NULL; tail = tail->next({

if )tail->next == tail(return true;

for )Node* curr = list->head; curr != tail; curr = curr->next({

if )tail->next == curr(return true;

}}

return false;}

1

1

0

שארית 4

שארית 0

שארית 1

שארית 2

שארית 3

00

0

1

1

01


JobHunt.co.il

.)1(O, וסיבוכיות הזיכרון שלו היא )O)n^2סיבוכיות הזמן של האלגוריתם היא

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

ניצחון או תיקו: השחקן שמתחיל, יכול להביא למצב שבו הוא ייקח את כל האיברים שנמצאים במקומות הזוגיים

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

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

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

במקומות אי זוגיים:o שנמצא במקום2, השחקן לוקח את איבר מספר 1אם היריב לוקח את איבר מספר ,

זוגי.o אם היריב לוקח את איבר מספרN-1 השחקן לוקח את איבר מספר ,N-2שנמצא ,

גם הוא במקום זוגי..לאחר כל איבר שהשחקן לוקח ממקום זוגי, היריב נאלץ לקחת איבר ממקום אי זוגי.לאחר כל איבר שהיריב לוקח ממקום אי זוגי, השחקן יכול לקחת איבר ממקום זוגי

53 תשובה לשאלה הוא חזקה שלמה של שתיים, נתייחס לשני מקרים:Aעל מנת לבדוק אם המספר

שווה לשתיים בחזקת מינוס אינסוף( או שלא.A. אפשר להחליט שכן )A = 0א.

(:1 )הביט הכי שמאלי שערכו MSB, עד ל-A. נסתכל על כל הביטים שמייצגים את A < 0ב.A 10...0 הוא חזקה שלמה של שתיים, אם ורק אם רצף הביטים שמייצג אותו הוא מהצורה. ממספר בעל רצף כזה של ביטים, כולם יתהפכו ונקבל מספר בעל רצף ביטים1אם נפחית

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

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

A & )A-1( = 0.

54 תשובה לשאלה פונקצית מחלקה מקבלת את הכתובת של האובייקט שקרא לה, אבל בצורה בלתי מפורשת

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

באחד הרגיסטרים. בונה את קוד האסמבלי, כך שהיא מקבלת את כתובת האובייקטVisual Studio 6.0הקומפיילר של

.ECXברגיסטר )חומר כללי: פונקציות מחלקה(.3לפירוט נוסף – חלק

55 תשובה לשאלה פיקסלים )ביטים( אפשר לייצג באמצעות בית אחד.8כל

בתים.N/8 פיקסלים, ולכן Nבכל שורה בתמונה ישנם


JobHunt.co.il

אפשרות ראשונה: (, כך שכל בית255 ל-0 עבור כל הערכים האפשריים שבית יכול לקבל )בין Look-Up Tableנכין א.

ימופה לבית ההפוך לו )מבחינת ערכי הביטים שלו(:void CreateLut)unsigned char lut]256[(

{for )int i=0; i<256; i++(

{lut]i[ = 0;

for )int j=0; j<8; j++(lut]i[ |= ))i>>j(&1(<<)8-1-j(;

}}

נעבור על כל שורה בתמונת הקלט, ולכל בית בשורה:ב.-נמצא בO)1( את הערך שאליו ממופה בית מספר x.בשורת הקלט את הערך שמצאנו בשלב הקודם, נשים בבית מספרN-x.בשורת הפלט

אפשרות שנייה: ביטים:8 של Bit-Fieldנגדיר א.

typedef struct{

unsigned char b1 :1;unsigned char b2 :1;

…unsigned char b8 :1;

}Byte;עבור כל שורה נבצע:ב.

Byte* inputPtr = )Byte*(inputRow;Byte* outputPtr = )Byte*(outputRow;

For )int i=0; i<N; i++({

outputRow]N-1-i[.b8 = inputRow]i[.b1;outputRow]N-1-i[.b7 = inputRow]i[.b2;

…outputRow]N-1-i[.b1 = inputRow]i[.b8;

} אוLook-Up Table יותר פעולות )השמה(, אבל אין צורך בהכנת ה-8באפשרות השנייה מבצעים פי

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

וסיבוכיות)O)M*Nבכל מקרה, בשתי האפשרויות, אם ההנחה הנ"ל נכונה, סיבוכיות הזמן היא .)O)M+Nהזכרון היא

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

איזה נקודות מתחילות קטע ואיזה נקודות מסיימות קטע. למשל, ניתן להצמיד מערך של ביטים, מסמן נקודת סיום. במידה ויש כמה נקודות בעלות קואורדינטת0 מסמן נקודת התחלה ו-1כאשר


JobHunt.co.il

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

, נעבור על רשימת הנקודות הממוינת ונבצע:Count = MaxCount = 0כעת נאתחל אם הנקודה הנוכחית היא נקודה שמתחילה קטע, נגדיל אתCount-1 ב. אם יש צורך, נעדכן אתMaxCount. אם הנקודה הנוכחית היא נקודה שמסיימת קטע, נקטין אתCount-1 ב.

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

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

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

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

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

.MaxCount = 1להיפך, כדי שנקבל של הנקודות הנתונות אין שימוש כלל.Yהערה: בקואורדינטות ה-

57 תשובה לשאלה Constructor:של מחלקה כלשהי לא יכול להיות וירטואלי, כי

של המחלקה שאליהV-Tableקריאה לפונקציה וירטואלית של אובייקט כלשהו מתבצעת בעזרת ה-שייך האובייקט.

המתאים, אבל המצביע הזה מאותחל רק בזמן ריצה, כאשרV-Tableכל אובייקט מחזיק מצביע ל-האובייקט נוצר.

לאConstructor של האובייקט, ולכן ה-Constructorכלומר, המצביע הזה למעשה מאותחל רק ב- וירטואלי. הרעיון מאחורי פונקציותConstructorיכול להיות וירטואלי. חוץ מזה, אין שום הגיון ב-

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

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

כאשר יוצרים ע"י הקצאה סטאטית אובייקט שנגזר ממחלקת הבסיס, אז בסיום הפונקציה )אם של האובייקטDestructorהאובייקט הוא לוקאלי( או התוכנית )אם האובייקט הוא גלובאלי(, ה-

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

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

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

של מחלקתDestructor קורא ל-delete של מחלקת הבסיס. אחרת, אופרטור ה-Destructorל- של המחלקה האמיתית של האובייקט לא מתבצע כלל.Destructorהבסיס של האובייקט, וה-

שנגזרת ממנה:B, וקיימת מחלקה Aלדוגמא, נניח שמחלקת הבסיס היא מתבצע:A* ptr = new Bעבור -אופרטור הnew מקבל את הסוג B-בצורה מפורשת(, וקורא ל( Constructor של מחלקה B.

מתבצע:delete ptrעבור -אם הDestructor של מחלקה A-הוא וירטואלי, אופרטור ה delete-קורא ל Destructorשל

.Bמחלקה .A של מחלקה Destructor מסיים, הוא קורא ל-B של מחלקה Destructorכשה-

-אם הDestructor של מחלקה A-הוא לא וירטואלי, אופרטור ה delete-קורא ל Destructor .Aשל מחלקה


JobHunt.co.il

לא נקרא כלל.B של מחלקה Destructorה- )חומר כללי: פונקציות מחלקה(.3לפירוט נוסף – חלק

58 תשובה לשאלה , נגדירAעל מנת למנוע פניה למערכת ההפעלה בעת הקצאה דינאמית של אובייקט מסוג

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

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

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

.NULLהמחלקה עצמה(. אפשרות נוספת היא פשוט להחזיר מצביע ,A: void* operator new)unsigned int stAllocateBlockחתימת האופרטור בתוך המחלקה

char chInit (; *Aדוגמא לקריאה לאופרטור:

a=new)6( A;

59 תשובה לשאלה :virtual את מנגנון הפונקציות הווירטואליות ללא שימוש במילה השמורה Cשיטה ליישם ב-++

מחלקה שמספקת ממשק של פונקציות וירטואליות, היא מחלקת בסיס למחלקות אחרות )שיורשותממנה(.

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

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

.type של מחלקת הבסיס ושל המחלקות שיורשות ממנה נאתחל את Constructorבכל יקבלtype הוא אף פעם לא וירטואלי, מובטח לנו שכאשר האובייקט נוצר, Constructorמכיוון שה-

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

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

יורשות ממנה.C ו-B היא מחלקת הבסיס, ושמחלקות Aנניח שמחלקה בעזרת מצביע מסוגA, כל קריאה לפונקציה של virtualמכיוון שלא ניתן להשתמש במילה השמורה

A תביא אותנו לפונקציה של ,A גם אם העצם המוצבע הוא מסוג B או C. ונזהה את סוגtype שנרצה שתהיה וירטואלית, נבדוק את הערך של Aלכן, בכל פונקציה של

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

B או C-נמיר את ה ,thisשברשותנו למצביע מתאים, ונקרא בעזרתו לפונקציה של המחלקה המתאימה.

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

:Aדוגמא ליישום של פונקציה וירטואלית במחלקה int A::func)(

{if )type == 'A'(


JobHunt.co.il

return 0;else if )type == 'B'(

return ))B*(this(->func;)(else //if )type == 'C'(

return ))C*(this(->func;)(}

הערות: השימוש במשתנהtypeובהמרת המצביעים )כמו בדוגמא הנ"ל( דומה לשימוש באופרטור

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

. על מנת להשתמש באופרטור הזה, צריך לוודא שקיימתNULLואם לא הוא מחזיר , שמאפשרת לקבל אינפורמציה לגבי סוג האובייקט בזמן ריצה )RTTIבקומפיילר אופציית

Run-Time Type Information.)-באופן כללי, גם השימוש בRTTIוגם הדוגמא הנ"ל ליישום של פונקציה וירטואלית, נוגדים

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

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

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

60 תשובה לשאלה נניח לשם הפשטות שיש במערך מספר זוגי של איברים:

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

( מכיוון שלכל זוג מספרים מספיק לבצע השוואה אחתif x<y נבצע סך הכל ,)N.השוואות ½½ ערכי מקסימום:N ½ ערכי מינימום ו-Nלאחר שקיבלנו

נעבור על ערכי המינימום ונמצא את הערך המינימלי מביניהם – סך הכלN.השוואות ½ נעבור על ערכי המקסימום ונמצא את הערך המקסימלי מביניהם – סך הכלN.השוואות ½

½.N½1 = N½ + N½ + Nסך הכל, מספר ההשוואות שביצענו הוא

61 תשובה לשאלה , על מנת לפתור את הבעיה בעזרת תכנון דינאמי:N על Mניעזר בטבלה בגודל

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

אורך הצלע של הריבוע שאותו היא מייצגת. , מכיוון שזהו אורך הצלע1בכל המשבצות בשורה הראשונה ובטור הראשון בטבלה נרשום ב.

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

נחשב את הערך המתאים לה באופן הבא:[i[]j]סדר השורות(, ולכל משבצת נבדוק את הצבע של משבצת[i[]j]( ושל שלוש המשבצות שלפניה [i-1[]j-1[ ,]i-1[]j[ ,]i[]j-

1].) אם הצבעים של חלק מהמשבצות שונים זה מזה, אז משבצת[i[]j]מייצגת ריבוע שאורך

.1הצלע שלו הוא אם הצבעים של כל המשבצות זהים זה לזה, אז משבצת[i[]j]מייצגת ריבוע שאורך

+ הערך המינימלי מבין הערכים שרשומים בשלוש המשבצות הנ"ל.1הצלע שלו הוא לסיום, נעבור על הטבלה ונמצא את הערך המקסימלי שרשום בה.ד.

נניח, למשל, שהתמונה נראית כך:BGGRRGGGGG


JobHunt.co.il

GGGGGGGBBBGGBBB

כאשר נגיע למשבצת הרביעית בשורה השלישית, הטבלה תיראה כך:1111112111

X22111

.X = 1 + Min)1,2,2( = 2נחשב את הערך של המשבצת הזאת כך:

62 תשובה לשאלה בתים מעבר לכמות הבתים הנדרשת, ונרשום בהם את מספר4 נקצה MyMallocבפונקציה

הבתים שהוקצו.void* MyMalloc)int size(

{void* ptr = malloc)sizeof)int(+size(;

((int)*ptr[)0 = ]sizeof)int(+size;return ptr;

} הבתים הראשונים את מספר הבתים שהוקצו, ונשחרר את כמות4 נקרא מ-MyFreeבפונקציה

הבתים הזאת.void MyFree)void* ptr(

{int size = ))int*(ptr(]0[;

free)ptr,size(;}

63 תשובה לשאלה ניהול החוצצים יתבצע באופן הבא:

."נייצג כל חוצץ באמצעות מבנה נתונים "באפר", שכולל כתובת זיכרון ודגל "פנוי" / "תפוס נקצהN חוצצים, ומחסנית שיכולה להכיל N באפרים". מכיוון שהתוכנה היא תוכנת" Real-

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

הפונקציהvoid InitBuffers)void* addresses]N[(:.)O)N "באפרים" בכתובות של החוצצים ובדגלי "פנוי", ונכניס אותם למחסנית – Nנאתחל

הפונקציהBuffer* GetBuffer)(: נוודא שהמחסנית לא ריקה, נוציא ממנה "באפר", נשנה את הדגל שלו ל"תפוס" ונחזיר אותו

.)O)1כפלט – הפונקציהvoid FreeBuffer)Buffer* buffer(:

נוודא שהדגל של ה"באפר" שקיבלנו כקלט הוא "תפוס", נשנה אותו ל"פנוי" ונכניס אותו.)O)1למחסנית –

שינוי השדות של מבנה הנתונים "באפר" יתאפשר רק בתוך הפונקציות הנ"ל.

64 תשובה לשאלה CLR R3//R3 = 0CLR R7//R7 = 0CLR R8//R8 = 0

Loop_R1:


JobHunt.co.il

DEC R1//R1 = R1 - 1INC R7//R7 = R7 + 1

Loop_R2:DEC R2//R2 = R2 - 1INC R8//R8 = R8 + 1INC R3//R3 = R3 + 1

JUMP R2 Loop_R2//if )R2 > 0( goto Loop_R2Restore_R2:

DEC R8//R8 = R8 - 1INC R2//R2 = R2 + 1

JUMP R8 Restore_R2//if )R8 > 0( goto Restore_R2JUMP R1 Loop_R1//if )R1 > 0( goto Loop_R1

Restore_R1:DEC R7//R7 = R7 - 1INC R1//R1 = R1 + 1

JUMP R7 Restore_R1//if )R7 > 0( goto Restore_R1

.JUMP ו-DEC אפשר לממש בעזרת הפקודות CLRאת הפקודה פעמים, ולכן גם אותה לאפשר לממש בעזרתDEC 15 שקול לביצוע הפקודה INCביצוע הפקודה

שתי הפקודות הנ"ל. ביטים,4. מכיוון שהפלט נתון ברגיסטר של 16, אז הקלט השני יוכפל ב-0אם קלט אחד הוא

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

*1-, 6*1-, 5*1-, 4*1-, 3*1-, 2*1-, 1*1לכן, מספיק לבדוק אותו עבור כל אחת מהמכפלות האלה: 7 ,-1*8.-

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

וירטואלית מתבצעת על סמך סוג האובייקט שבאמצעותו הפונקציה נקראת, ושאת המצביע אליו (. פונקציה סטאטית לא מקבלת מצביע לסוג האובייקט שבאמצעותו היא נקראת,thisהיא מקבלת )

ולכן אין משמעות לסוג שלו. למעשה, אפשר באותה מידה לקרוא לה באמצעות המחלקה שאליה.)(MyClass::Func שקולה לקריאה )(MyObject->Funcהיא שייכת. לדוגמא, הקריאה

)חומר כללי: פונקציות מחלקה(.3לפירוט נוסף – חלק

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

שמחבר ביניהן(.


JobHunt.co.il

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

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

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

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

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

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

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

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

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

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

לאיש השלישי.האיש השלישי – מחבר את המספר שקיבל מהאיש השני למשכורת שלו ואומר את התוצאה

לאיש הראשון. האיש הראשון – מחסרX-3 מהמספר שקיבל מהאיש השלישי, מחלק את התוצאה ב

ומקבל את הממוצע.

71 תשובה לשאלה נסתכל על החדר כעל קופסת קרטון תלת-מימדית, שאותה נפרוס למשטח דו-מימדי באופן הבא:

30

12

12


JobHunt.co.il

במשטח שקיבלנו, נחבר את שני השקעים בעזרת קו ישר.√)( פאות של החדר. אפשר לחשב את אורכו לפי משפט פיטגורס: 6 )מתוך 5הכבל יעבור דרך

32²+24² = )40.

72 תשובה לשאלה הגבר הראשון צריך לשים את הקונדום הראשון ועליו את הקונדום השני.

הגבר השני צריך לשים את הקונדום השני.הגבר השלישי צריך לשים את הקונדום הראשון הפוך ועליו את הקונדום השני.

73 תשובה לשאלה תוך שימושN. על מנת למצוא את N הוא 1 שערכם x, ומספר הביטים ב-xנניח שמספר הקלט הוא

איטרציות:Nב-, באופן הבא:1 את הביט הימני ביותר שערכו xבכל איטרציה נאפס ב-א.

0...10 זה הייצוג הבינארי של ...x.1...01 זה הייצוג הבינארי של ...x-1. נבצע פעולתand-בין שני הערכים ונכניס את התוצאה ל x: x = x & )x-1(.

הוא מספר האיטרציות שביצענו.N יגיע לאפס, נדע שהערך של xכאשר הערך של ב.

קיר קידמי

רצפה

3012

קיר אחורי

תקרה קיר ימני

קיר שמאלי

12

12

12

12

32

24

20 Job Interviews and Answers

Documents

Transcript of 20 Job Interviews and Answers