תכנות מתקדם בשפת C חוברת תרגילים - 1 -

Transcript

1 תכנות מתקדם בשפת C חוברת תרגילים - 1 -

2 קלט פלט. MaxMult MaxMult שאלה א. כתבו תוכנית המדפיסה לוח כפל בגודל 10 ב. כתבו תוכנית המקבלת מספר,,MaxMult ומדפיסה לוח כפל בגודל לדוגמא עבור: MaxMult=4 יודפס: הנחיות לשני הסעיפים ההדפסות צריכות להיות בצורת טבלה ועל כל שדה בטבלה להיות מיושר לימין (כך שבכל טור ספרת האחדות תהיינה אחת מעל השנייה, ספרת העשרות תהיינה אחת מעל השנייה, וכך הלאה עבור כל הספרות) הקפידו לא להכניס רווחים מיותרים (לפני המספר שבפינה הימנית תחתונה צריך להופיע רווח אחד בדיוק). שאלה 2 כתבו את הפונקציה: void printformattedintegers(char* format, char* numbers) הפונקציה מקבלת כקלט מחרוזת,,format המכילה פורמט להדפסה של מספרים וכן מחרוזת,,numbers המכילה מספרים שלמים בבסיס דצימלי מופרדים במספר כלשהו של רווחים לבנים. על הפונקציה להדפיס את המספרים מהמחרוזת,numbers בהתאם לתווי ההסבה שב- format. כך שתו ההסבה הראשון ב- formatיקבע כיצד ייוצג המספר הראשון ב- numbers, תו ההסבה השני יקבע כיצד ייוצג המספר השני וכך הלאה (בדומה ל- printf ). מחרוזת הפורמט יכולה להכיל את תווי ההסבה הבאים (כמו ב- :(printf d% ממיר int לטקסט המכיל ייצוג עשרוני של המספר x% ממיר int לטקסט המכיל ייצוג הקסהדצימלי (בסיס 16) של המספר o% ממיר int לטקסט המכיל ייצוג אוקטלי (בסיס 8) של המספר וכן מחרוזת הפורמט יכולה להכיל את תווי ההסבה הבאים אשר אינם חוקיים ב- :printf b% ממיר int לטקסט המכיל ייצוג בינארי (בסיס 2) של המספר r% ממיר int לטקסט המכיל ייצוג רומי של המספר כמו כן מחרוזת הפורמט יכולה להכיל תווים שאינם תווי הסבה, אשר מודפסים כמו שהם

3 דוגמאות: הקריאה: printformattedintegers("dec: %d Hex: %x Roman: %r"," ") תגרום להדפסת הפלט: Dec: 123 Hex: A Roman: IX הקריאה: printformattedintegers("%b in Binary is %o in Octal","18 18") תגרום להדפסת הפלט: in Binary is 22 in Octal הנחיות: 1. היעזרו בוויקיפדיה כדי למצוא את התיאור המלא של שיטת הספירה הרומית: חפשו את הערך:"ספרות רומיות" 2. הניחו כי הקלט לפונקציה תקין, כלומר הניחו כי המחרוזת numbers אכן מכילה מספרים שלמים מיוצגים בבסיס 10 ומופרדים ברווח לבן וכי format מכיל מחרוזת פורמט חוקית וכן שמספר תווי ההסבה במחרוזת הפורמט מתאים למספר המספרים שהתקבלו במחרוזת.numbers 3. השתמשו ככל הניתן בפונקציות הקלט/פלט שנלמדו בשיעור printf,scanf,sscanf,sprintf וכו'. 4. ניתן להיעזר בפונקציה strtok (חפשו תיעוד המסביר כיצד להשתמש בה) אך בהחלט ניתן להסתדר גם בלעדיה. 5. הגדירו פונקציות עזר וחלקו את הבעיה לתת בעיות

4 מצביעים והקצאות דינאמיות שאלה 1 א. כתבו את הפונקציה: int** pointersort(int* arr, unsigned int size, char ascend_flag); הפונקציה מקבלת כקלט מערך של מספרים שלמים,,arr את גודלו, sizeודגל, ascend_flagאשר אם ערכו שונה מאפס המיון הוא עולה, אחרת המיון יהיה יורד. על הפונקציה להחזיר מערך של מצביעים, כך שהמצביעים במערך יצביעו על איברי arr בצורה ממוינת על-פי.ascend_flag כלומר, אם ascend_flag=1 המצביע בתא ה- 0 של המערך המוחזר מצביע לאיבר המינימלי. הערה: ממשו את המיון בשיטת.merge-sort arr = לדוגמא: אם המערך arr הוא אז המערך המוחזר יהיה: ב. כתבו גרסא נוספת לפונקציה. הפעם כותרת הפונקציה תהיה: void pointersort(int* arr, unsigned int size, char ascend_flag, int*** pointers); הפונקציה מקבלת מערך של מספרים שלמים,,arr גודלו, size ודגל, ascend_flag אשר אם ערכו שונה מאפס המיון הוא עולה, אחרת המיון יהיה יורד. הפעם על הפונקציה להחזיר כפרמטר פלט את מערך המצביעים. שאלה 2 בהינתן פולינום עם מקדמים שלמים מהצורה: n C X + C X C X + C n n 1 1 n כל איבר בפולינום נקרא מונום. נגדיר רשומה לייצוג מונום כנ"ל באופן הבא: typedef struct monom{ המקדם// coefficient; int החזקה // power; int }Monom; מבנה הנתונים לייצוג פולינומים: מערך של רשומות מטיפוס,Monom המקיים: המערך לא יכיל מונום שמקדמו 0. המונומים במערך יופיעו בסדר חזקות יורד ממש (כלומר המונום עם החזקה הגדולה ביותר יופיע בתא הראשון במערך). כתבו תוכנית הקולטת מהמשתמש שני פולינומים, ומדפיסה את פולינום הסכום שלהם ואת פולינום המכפלה שלהם, כל אחד בשורה נפרדת. הערות: 1. כל פולינום בקלט יהיה שורה באורך לא ידוע של זוגות (מקדם וחזקה). כך למשל השורה: x + 7x 5x מייצגת את הפולינום: 8 2. הדפסת פולינום צריכה להיות בסדר חזקות יורד, ללא מקדמים שהם

5 יש להדפיס: - 8 5x.8x^4 + 7x^ x + 7x 5x למשל את הפולינום: 8 שאלה 3 כתוב תוכנית הקולטת שורות טקסט מהמשתמש ואוגרת אותן במערך של מחרוזות. התוכנית תקלוט בהתחלה מספר הקובע את גודל המאגר, ולאחר מכן תקלוט שורות אותן תכניס למאגר. במידה והמאגר מתמלא, יש "לזרוק" את השורה הותיקה ביותר. בנוסף לתחזוקה של מבנה הנתונים המתואר לעיל, על התוכנית לאפשר למשתמש לשחזר שורות מתוך המאגר. פקודות השחזור ניתנות כאן: משחזרת את השורה האחרונה שהוכנסה למאגר.!! משחזרת את שורה מספר n. במידה ואין כזו - תודפס הודעת שגיאה. n! (מספרי השורות ניתנים באופן רציף מתחילת התוכנית ועד סיומה) משחזרת את מספר השורה האחרונה. L!.str משחזרת מהמאגר את השורה האחרונה שלא הופיעה בה המחרוזת!~str במידה ואין כזו, תודפס הודעת שגיאה. במידה משחזרת מהמאגר את השורה האחרונה שהתחילה במחרוזת.str!str ואין כזו, תודפס הודעת שגיאה. מדפיסה את תוכן המאגר. כל שורה תופיע אחרי מספר השורה. (מספרי השורות ניתנים באופן רציף מתחילת התוכנית ועד סיומה)!print יציאה.!quit שחזור שורה פירושו להדפיס את השורה המשוחזרת. אם השחזור הצליח, יש להכניס למאגר את השורה המשוחזרת כולה. אחרת, אין להכניס דבר למאגר. דוגמת הרצה (הקלט מהמשתמש מופיע בפונט מודגשונטוי והפלט שהתוכנית מדפיסה מופיע בפונט רגיל) Please enter the history storage size > 5 The storage size was set to 5 > some text > some more text > and more text >!2 some more text > hello world >!! hello world >!! hello world >!2 Could not restore line number 2, currently lines 3-7 are in the storage >!print 3. and more text 4. some more text 5. hello world 6. hello world 7. hello world >!~hello some more text >!some some more text >!L Number of last line is 9-5 -

6 >!quit Thanks for using the history application, bye bye הערות 1. לא ניתן להניח אורך שורה מקסימאלי 2. ניתן להניח כי כל שורה שאינה פקודת שחזור תתחיל באות אנגלית 3. פתרון יעיל הוא פתרון אשר פעולת הכנסה למאגר תתבצע בזמן (1)O שאלה 4 כתוב פונקציה המקבלת שני פרמטרים שהם שתי מחרוזות. הפונקציה מכפילה במחרוזת הראשונה את כל התווים המופיעים במחרוזת השנייה. הפונקציה מחזירה מחרוזת חדשה המכילה את הרצף שלאחר ההכפלה. לדוגמא: ( l strrepתשנה ("hello world", את המחרוזת הראשונה ל hellllo worlld" אם הפונקציה הופעלה בשנית, עם פרמטר ראשון שהוא המחרוזת הריקה ("" או,(NULL יש לבצע את ההכפלה על תוצאת ההפעלה הקודמת של הפונקציה. לדוגמא: "or") strrepתשנה (NULL, את המחרוזת הראשונה ל helllloo woorrlld" - 6 -

7 רשימות מקושרות שאלה 1 נתונים המבנים הבאים לייצוג רשימה מקושרת של תווים: typedef struct list_node { char* dataptr; struct list_node* next; }ListNode; typedef struct list { ListNode* head; ListNode* tail; }List; נתונה רשימה מקושרת שנתוניה הם ספרות, ואותיות אנגליות קטנות בלבד. הרשימה המקושרת במקורה הכילה את המידע הבא על תלמיד: שמו הפרטי של התלמיד (המופיע באותיות קטנות) אות אחר אות ברשימה, ואחריו מופיע ציונו הממוצע (הניתן בספרות המייצגות מספר חיובי שלם) סיפרה אחר סיפרה ברשימה. לרוע המזל, כתוצאה מבאג במחשב, נשזרו התווים אלו באלו, והתקבלה רשימה מעורבלת. דוגמה: רשימה שבמקור הכילה את התווים mully94 כאשר m היה הנתון בצומת הראשון, u היה הנתון בצומת השני, וכ"ו (כלומר שמו הפרטי הוא,mully וציונו 94), שונתה וכעת היא מכילה את התווים: m9ul4ly (כאשר m הוא הנתון בצומת הראשון, 9 הוא הנתון בצומת השני, וכ"ו). שימו לב כי סדר התווים והספרות המקורי נשמר בתוך הערבול. (לדוגמא, u יבוא אחרי l m, יבוא אחרי u, וכו'). כתבו פונקציה המקבלת רשימה מעורבלת ומחזירה מבנה לייצוג תלמיד (שיוגדר להלן) המכיל את שמו הפרטי ואת ציונו הממוצע של התלמיד המתקבלים מהפרדת המילים ברשימה המעורבלת. Student unscramble (List lst); ה prototype של הפונקציה הוא: כאשר מבנה של תלמיד מוגדר להלן: השדה והשדה typedef struct student { List first; int grade; } Student; firstהוא רשימה המייצגת את שמו הפרטי של הסטודנט אות אחר אות. gradeהוא מספר המייצג את ממוצע ציוניו של הסטודנט. אין להשתמש בהקצאה דינאמית, אלא לשנות מצביעים ברשימת הקלט. הערות: - 7 -

8 שאלה 2 נתונה ההגדרה הבאה לייצוג רשימה מקושרת של מספרים שלמים: typedef struct listnode{ int* dataptr; struct listnode* next; }ListNode; typedef struct list { ListNode* head; ListNode* tail; }List; List merge(list lst1, List lst2); כתבו את הפונקציה הבאה, בארבע גרסאות: הפונקציה מקבלת כקלט lst1 ו- lst2, שתי רשימות מקושרות ממוינות בסדר יורד של ערכים עליהם מצביעים השדות.dataPtr על הפונקציה למזג את שתי הרשימות לרשימה ממוינת אחת המכילה את כל האיברים של רשימות הקלט. על הפונקציה להחזיר את הרשימה הממוזגת. א. ב. ג. בגרסא זו, הפונקציה איננה רקורסיבית ועליה ליצור רשימה חדשה. הפונקציה לא תשנה הצבעות ברשימות lst1 ו- lst2 (בסוף ריצת הפונקציה שתי הרשימות נותרות ללא שינוי). בגרסא זו, הפונקציה איננה רקורסיבית ועליה למזג את שתי הרשימות לרשימה אחת ממוינת ע"י שינוי מצביעים בלבד (ללא שימוש בהקצאות חדשות). בגרסא זו, הפונקציה רקורסיבית ועליה ליצור רשימה חדשה. ד. בגרסא זו, הפונקציה רקורסיבית ועליה למזג את שתי הרשימות ע"י שינוי מצביעים. הערה: בסעיפים ג' ו- ד' הפונקציה אינה חייבת להיות רקורסיבית בעצמה, היא יכולה להיות פונקציה העוטפת פונקציה רקורסיבית (פונקציה אשר מפעילה לפונקציה רקורסיבית)

9 שאלה 3 נתונה ההגדרה הבאה לייצוג רשימה מקושרת של מספרים שלמים: typedef struct listnode{ int* dataptr; struct listnode* next; struct listnode* prev; } ListNode; typedef struct list { char sgn; ListNode* head; ListNode* tail; } List; ניתן לייצג מספר שלם גדול בעזרת הסימן שלו ורשימה של ספרותיו לפי הסדר כאשר הצומת הראשון ברשימה מכיל מצביע לספרה הימנית והצומת האחרון מכיל מצביע לספרה השמאלית. למשל את המספר 197 נייצג ברשימה: א. כתבו את הפונקציה: num); void printnumber(list שמקבלת מספר המיוצג ברשימה כפי שתואר, ומדפיסה אותו. (הפונקציה יכולה להיות רקורסיבית או איטרטיבית לפי בחירתכם). יש להדפיס את הסימן בין אם המספר חיובי ובין אם הוא שלילי. ב. כתבו את הפונקציה: void subtractnumbers(list n1, List n2, List* result); שמקבלת 2 רשימות שמייצגות שני מספרים ומצביע לרשימה שלישית ומעדכנת את resultלהצביע על רשימה השלישית המייצגת את הפרש המספרים n1. - n2 ג. כתבו את הפונקציה: mod); void modnumbers(list n1, List n2, List* שמקבלת 2 רשימות שמייצגות שני מספרים ומצביע לרשימה שלישית, ומעדכנת את modלהצביע על רשימה השלישית המייצגת את שארית החלוקה בין שני המספרים. הערה: בסעיפים ב' ו- ג' אין להשתמש באלגוריתם הממיר את המספרים המיוצגים ברשימות למשתנים מטיפוס int או double ולבצע את החיבור והכפל עליהם (גישה כזו מחמיצה את המטרה של ייצוג המספרים ברשימה). מה גם שבהחלט ייתכן והמספר לא ניתן כלל לייצוג שכזה בגלל אורכו

10 שאלה 4 מעוניינים לשמור נתונים על נקודות במישור ששיעורי הקורדינטות שלהן הם מספרים שלמים. על-מנת לחסוך במקום הציעו לשמור את הנקודות במבנה הבא: המבנה לעיל שומר את הנקודות: (5,3), (5,8), (7,4), (9,-4), (9,9), (9,9) שימו לב, שנקודה יכולה להופיע יותר מפעם אחת. החיסכון בא לידי ביטוי בכך שהקורדינטה X נשמרת פעם אחת בלבד עבור אוסף נקודות אשר להן שיעור קורדינטה X זהה ואשר נבדלות רק בערכי הקורדינטה Y. שימו לב כי המבנה הנ"ל עושה שימוש בשני סוגים שונים של רשימות אשר כל אחת מהן ממויינת. typedef struct XlistNode{ } XListNode; typedef struct YlistNode{ } YListNode; typedef struct Ylist { } YList; typedef struct list { } List; א. כתבו את הפונקציה unsigned int getpairoccurrences(list coord_list, int x, int y); אשר סופרת ומחזירה כמה פעמים מופיעה הנקודה (x,y) ב- coord_list. ב. כתבו את הפונקציה unsigned int getyoccurrences(list coord_list, int y); אשר סופרת ומחזירה כמה נקודות (y,*) נמצאות ב- coord_list. כלומר כאלו אשר שיעור הקורדינטה Y שלהן שווה לפרמטר y

11 ג. כתבו את הפונקציה unsigned int getxoccurrences(list coord_list, int x); אשר סופרת ומחזירה כמה קורדינטות (*,x) נמצאות ב- coord_list. כלומר כאלו אשר שיעור הקורדינטה X שלהן שווה לפרמטר x. ד. כתבו את הפונקציה int insertcoordinate(list *coord_list, int x, int y); אשר מוסיפה ל- coord_list את הנקודה.(x,y) אם הנקודה נמצאת כבר, הפונקציה תחזיר 1, אחרת הפונקציה תחזיר 0. בכל מקרה, הפונקציה תוסיף את הנקודה. ה. כתבו את הפונקציה int removecoordinate(list *coord_list, int x, int y); אשר מוחקת מ- coord_list את הנקודה.(x,y) אם הנקודה מופיעה יותר מפעם אחת ב-,coord_list יש למחוק רק את אחד המופעים. במקרה וזו הנקודה היחידה עם שיעור ה- X שצויין, יש למחוק גם את התא המתאים ברשימת שיעורי קורדינטות ה- X. לדוגמא, לאחר הפעלת removecoordinate( &coord_list, 7, 4); על המבנה שבעמוד הקודם, יתקבל המבנה על הפונקציה removecoordinate להחזיר את אחד מהערכים הבאים: אם הנקודה לא נמצאה, הפונקציה תחזיר 1, אם יש מופע נוסף לנקודה, הפונקציה תחזיר 2, אם זו הייתה הקורדינטה היחידה עם השיעור X שצויין, הפונקציה תחזיר 3, בכל מקרה אחר, הפונקציה תחזיר

12 עצים בינאריים שאלה 1 נתונות ההגדרות הבאות עבור עץ בינארי של מספרים: typedef struct treenode { int data; struct treenode *left; struct treenode *right; }TreeNode; typedef struct tree { TreeNode *root; }Tree; כתבו את הפונקציה : int HowMany (Tree tr) הפונקציה מקבלת כפרמטר עץ,,tr ומחזירה את מספר תתי העצים עבורם מתקיים התנאי הבא: מספר האברים החיוביים בתת העץ (כולל השורש) מהווה לפחות מחצית מכל האיברים בתת העץ. (הערה: עלה שהנתון בו הינו חיובי נכלל בספירה). לדוגמא, בעץ שלהלן ישנם 6 צמתים, כלומר 6 תתי עץ. 3 מתוכם (האיברים שמכילים את 12, את 3 ואת 5) מקיימים את התכונה, והפונקציה שתקבל את העץ הזה כפרמטר תחזיר

13 שאלה 2 פעמים רבות הקומפיילר בונה עץ ביטוי לצורך חישוב ביטוי חשבוני שמופיע בקוד. לשם הפשטות, נניח שבביטוי שלנו יופיעו רק מספרים חד ספרתיים (אופרנדים) ופעולות חשבוניות (בינריות) בסיסיות (אופרטורים) חיבור, חיסור, כפל, חילוק ומודולו. ( ) ( (3 + 7) * 9) ( (2 + 5) * (8 / 2)) נניח שסביב כל אופרטור ושני האופרנדים עליהם הוא פועל מופיעים סוגריים. למשל: נגדיר עץ ביטוי באופן הבא: צומת בעץ יכול להכיל אופרטור או אופרנד. צומת עם בנים יכיל אופרטור אותו יש להפעיל על הביטויים המיוצגים ע"י תת העץ השמאלי ותת העץ הימני. עלים יכילו אופרנדים. דוגמאות: (4+5) ((3 + 7) * 9)

14 ( (2 + 5 ) * (8 / 2) ) כתבו תכנית הקולטת מהמשתמש מחרוזת המכילה ביטוי לפי ההגדרות בשאלה, בונה עץ ביטוי ומחשבת את ערך הביטוי תוך שימוש בעץ. על התכנית להציג הודעת שגיאה אם המחרוזת אינה ביטוי תקין. המחרוזת אינה תקינה אם אינה כתובה בהתאם לכללים שנכתבו לעיל. כלומר, הכוונה היא לטעויות שניתן לגלות בזמן קומפילציה ולא בזמן ריצה. לדוגמא, סוגריים לא תקינים היא טעות זמן קומפילציה אולם חלוקה באפס היא טעות זמן ריצה מכיוון שהיא עלולה להתגלות רק אחרי שבוצע חישוב על תת-עץ מסויים (ולכן אותה אין צורך לבדוק)

15 שאלה 3 נתונים המבנים הבאים עבור עץ בינארי ועבור רשימה מקושרת: typedef struct listnode { int data; struct listnode* next; } ListNode; typedef struct list { ListNode* head; ListNode* tail; } List; typedef struct treenode { int data; struct treenode* parent; struct treenode* left; struct treenode* right; } TreeNode; typedef struct tree{ TreeNode* root; /*רשימה מקושרת של כל העלים בעץ */ leaflist; List } Tree; #define LEFT 0 #define RIGHT 1 Tree AddNode (Tree *tr, TreeNode *p, int branchselect, int data); כתבו את הפונקציה הבאה: הפונקציה מקבלת עץ בינרי,tr צומת בעץ הבינרי p, נתון חדש data אותו יש להכניס לעץ מתחת ל p. הצד אליו יכנס הנתון החדש יקבע בהתאם לערך שיופיע ב.branchSelect שימו לב שבמבנה העץ מופיעה גם רשימה מקושרת של עלים. הרשימה צריכה להיות מעודכנת ונכונה לאחר כל הוספה של איבר לעץ

16 דוגמא לעץ כזה: 1 לשם ההבהרה, אם נקבל בקשה להכניס את המספר 16 בצד שמאל של העלה המכיל את הערך 27 בקריאה: AddNode של העלה המכיל את הערך (tr, 27,כתובת LEFT, ;(16 נקבל את מבנה הנתונים הבא: tr הבהרות נוספות: אם ערכו של p הוא NULL הכוונה היא להכניס את האיבר במקום שורש העץ. במקרה זה, שורש העץ יהפוך להיות הילד של האיבר החדש בהתאם לכתוב ב-.branchSelect p יכול להצביע גם על איברים בעץ שיש להם כבר ילדים (איברים פנימיים בעץ) ולא רק על עלים. במקרה כזה, ובמידה והאיבר החדש אמור להיכנס במקומו של ילד שקיים כבר, הילד הנוכחי יהפוך להיות הילד של האיבר החדש בהתאם למיקומו המקורי. כלומר, אם הוא היה הילד השמאלי של p, הוא יהפוך להיות הילד השמאלי של האיבר החדש. רשימת העלים תמיד מכילה את כל העלים מסודרים לפי סדר הופעתם בעץ, משמאל לימין. לשם פשטות, ניתן להניח שנתון לא מופיע פעמיים בעץ

17 typedef struct treenode{ int data; struct treenode* left; struct treenode* right; } TreeNode; שאלה 4 עץ בינארי מוגדר כך: typedef struct tree{ TreeNode* root; } Tree; void printbylevels(tree tr); כתבו את פונקציה: המדפיסה את הנתונים בעץ tr לפי רמות (קודם את הנתון ברמה 0, אחריו את נתונים ברמה 1, אחריהם את הנתונים ברמה 2, וכך הלאה), כל רמה תודפס משמאל לימין. על הפונקציה לרוץ ביעילות (n, )Θ כאשר n הוא מספר הצמתים הכולל בעץ. למשל עבור העץ: יודפס: הערות: 1. בכדי לעמוד בדרישות היעילות ייתכן ותרצו להשתמש במבנה נתונים נוסף. 2. אין להשתמש במשתנים סטאטיים

18 קבצים שאלה 1: כתבו תכנית המקבלת 2 פרמטרים. הפרמטר הראשון יהיה שם של קובץ בינארי והשני מספר שלם, x. נתון שהקובץ בנוי בפורמט הבא: בקובץ ישנן x מחרוזות, כאשר לפני כל מחרוזת יש מספר מטיפוס int המציין את גודלה, ולאחר מכן רצף באורך זה של תווים המייצגים את המחרוזת עצמה (ללא '0\' בסופה). כל מחרוזת מורכבת מאותיות קטנות וגדולות בלבד. למשל, אם x הוא 3 הקובץ מבחינה לוגית יכול להיראות: 5aBCde6aaBTRy4BBbb כלומר בקובץ ישנן 3 מחרוזות, הראשונה באורך 5 אותיות והיא,"aBCde" השניה באורך 6 אותיות והיא "aabtry" והשלישית באורך 4 אותיות והיא."BBbb" על התכנית לבצע את המשימות הבאות: לייצר מערך של מחרוזות, שגודלו x וכל מחרוזת בו היא האותיות הקטנות בלבד הלקוחות בהתאמה מכל מחרוזת שבקובץ. למשל, עבור הדוגמא הקודמת, התכנית תייצר מערך של 3 מחרוזות ואלו הן: הראשונה היא "ade" השניה "aay" והשלישית."bb" לייצר קובץ טקסט אליו יודפסו המחרוזות בצורה ממויינת (מבחינה לקסיקוגרפית). למשל, בדוגמא שלנו קובץ הטקסט שיווצר יראה: aay ade bb שמו של הקובץ המיוצר הוא כשמו של קובץ הקלט, בתוספת ".txt" בסוף. למשל: נניח ששם קובץ הקלט הוא "file.bin" שם הקובץ שייווצר יהיה."file.bin.txt"

19 typedef struct employee { int name_length; char * name; float salary; } Employee; שאלה 2 נתונה ההגדרה הבאה לרשומה: כתבו תכנית המקבלת 2 פרמטרים. הפרמטרים הינם שמות של 2 קבצים בינאריים, להלן file1 ו-.file2 נתון שהקובץ file1 הינו קובץ שמאחסן אברים מסוג Employee כלומר בנוי בפורמט הבא: בקובץ ישנם x איברים (x אינו ידוע), כאשר כל Employee מתחיל במספר מטיפוס int המציין את אורך השם, לאחר מכן רצף באורך זה של תווים המייצגים את השם עצמו (ללא '0\' בסופה) ולאחר מכן מספר בייצוג float המהווה את המשכורת. למשל, אם x הוא 2 הקובץ מבחינה לוגית יכול להיראות: 5danny ruti כלומר בקובץ ישנם 2 עובדים, הראשון שמו מכיל 5 אותיות והוא "danny" ומשכורתו והשניה שמה מכיל 4 אותיות והוא "ruti" ומשכורתה (בקובץ הבינארי כמובן אין רווחים ובדוגמא יש רווח בין העובדים להמחשה בלבד. כמו כן המספרים ייוצגו בקובץ באופן בינארי). הקובץ השני מכיל x מספרים מסוג float המהווים תוספת, בהתאמה, למשכורותיהם של העובדים הרשומים בקובץ.file1 למשל, בהמשך לדוגמא הקודמת, הקובץ יכול להכיל את המספרים 100 ו משמעות הדבר שמשכורתו של danny אמורה לעלות ב- 100 ומשכורתה של רותי ב ניתן להניח שמספר תוספות השכר בקובץ file2 הוא כמספר העובדים בקובץ.file1 על התכנית לעדכן את הקובץ file1 כך שיכיל את העובדים ומשכורותיהם המעודכנות (בהתאם לתוספות הרשומות ב- (file2 בסדר יורד מהעובד בעל השכר הגבוה ביותר לנמוך ביותר תוך שימוש במערך של מצביעים ל- Employee כאשר גודלו של המערך יהיה כמספר העובדים בקובץ.file1-19 -

20 שאלה 3 בשאלה זו נעסוק בייצוג של תמונה המורכבת מתווים. נתונה ההגדרה הבאה לייצוג תמונה טקסטואלית: כאשר typedef struct textpicture{ int numrows; int numcols; PicList pic; }TextPicture; numrowsו- numcols מחזיקים את ממדי התמונה (מספר השורות ומספר העמודות בתמונה בהתאמה), וב- picשומרים את התווים מהם מורכבת התמונה ברשימה מקושרת. הטיפוס PicList (ממנו תוגדר הרשימה של התווים בתמונה) מוגדר באופן הבא: typedef struct piclistnode{ תו בתמונה// data; PicChar struct piclistnode* next; }PicListNode; typedef struct piclist{ PicListNode* head; PicListNode* tail }PicList; כל תו בתמונה (איבר ברשימה) הוא מטיפוס.PicChar והוא מוגדר באופן הבא: typedef struct picchar{ מיקום התו// position; Point התו// ch; char }PicChar; typedef struct point{ int x; int y; }Point;

21 א. היות שצפויים להיות הרבה תווי רווח בתמונה, לצורך צמצום גודל הייצוג של התמונה, יישמרו ברשימה המקושרת (שדה picשל (TextPicture רק תווים השונים מהתו רווח. למשל כדי לייצג את התמונה הבאה: 5 שורות # $ # $ 8 עמודות נגדיר משתנה מטיפוס,TextPicture אשר השדות numrowsו- numcols יהיו מאותחלים ב- 5 וב- 8 בהתאמה, והשדה pic יכול להיות הרשימה הבאה: (4,2,'$') (3,1,'#') (2,2,'$') (3,2,'#') NULL כתבו את הפונקציה הבאה: void painttextpicture(textpicture textpic, char* filename); הפונקציה מקבלת תמונה textpic בייצוג שתואר לעיל ו"מציירת" את התמונה הנ"ל באופן מפורש לקובץ (טקסט) ששמו.filename '' '' '' '' '' '' '' '' '\n' '' '' '' '#' '' '' '' '' '\n' '' '' '$' '#' '$' '' '' '' '\n' '' '' '' '' '' '' '' '' '\n' '' '' '' '' '' '' '' '' '\n' למשל עבור התמונה לעיל ייווצר הקובץ הבא: הערות: 1. התו השמאלי עליון של התמונה ממוקם ב: (0,0) וביחס לנקודה זו נקבעים המיקומים של שאר התווים. 2. התווים ברשימה לא מופיעים בסדר ממוין כלשהו

22 ב. כתבו את הפונקציה הבאה: TextPicture * opentextpicture(char* filename); הפונקציה מקבלת כקלט את filename,שם של קובץ טקסט, המכיל תמונה טקסטואלית. הפונקציה מייצרת ומחזירה מצביע לנתון מטיפוס TextPicture,אשר מהווה ייצוג בזיכרון לתמונה הנמצאת בקובץ.filename הרשימה שמכילה את התווים (שדה pic של (TextPicture תורכב רק מהתווים שאינם רווח מסודרים לפי עמודות, בכל עמודה סדר התווים יהיה מלמעלה למטה. כלומר, ראשונים יופיעו התווים שאינם רווח בעמודה הראשונה מסודרים מלמעלה למטה, אחריהם התווים שאינם רווח מהעמודה השנייה מסודרים מלמעלה למטה, וכך הלאה. למשל עבור התמונה הבאה: 5 שורות # $ # $ 8 עמודות הפונקציה תחזיר מצביע על נתון,TextPicture אשר השדות numrowsו- numcols יהיו 5 ו- 8 בהתאמה, והשדה pic יהיה הרשימה הבאה: (2,2,'$') (3,1,'#') (3,2,'#') (4,2,'$') NULL הערות: 1. התו השמאלי עליון של התמונה ממוקם ב: (0,0) וביחס לנקודה זו נקבעים המיקומים של שאר התווים. 2. ניתן להניח כי התמונה מכילה תווים השונים מרווח. 3. בסוף כל שורה בתמונה מופיע התו 'n\'

23 ג. כתבו את הפונקציה הבאה: void replicatepicture(textpicture srcpic, int m, int n, char* reppicfilename); הפונקציה מקבלת כקלט את srcpic,משתנה מטיפוס,TextPicture המכיל תמונה טקסטואלית. הפונקציה מייצרת קובץ טקסט בשם,repPicFileName שיכיל תמונה טקסטואלית שהיא ריצוף בגודל של m-by-n של עותקים של התמונה המקורית.srcPic למשל עבור 3=m ו- 2=n ועבור srcpicשמכיל את התמונה הבאה: 5 שורות # $ # $ 8 עמודות הפונקציה תייצר את קובץ הטקסט אשר יכיל את התמונה הבאה: # # $ # $ $ # $ 15 שורות # # $ # $ $ # $ # # $ # $ $ # $ 16 עמודות הערות: 1. ניתן להניח כי התמונה המקורית מכילה תווים השונים מרווח. 2. בסוף כל שורה בתמונה מופיע התו 'n\'

24 ד. כתבו את הפונקציה הבאה: void mergepictures(textpicture* bigpic, char* smallpic); הפונקציה מקבלת כקלט את bigpic,משתנה מטיפוס,TextPicture המכיל תמונה טקסטואלית ואת,smallPic שם של קובץ טקסט, המכיל תמונה טקסטואלית. נתון כי smallpic היא תמונה הקטנה ממש מ- bigpic בכל אחד מהמימדים (גם השורות וגם העמודות). על הפונקציה לעדכן את bigpic לתמונה שהיא איחוד של שתי התמונות כך ש- smallpic מחליפה את הפינה הימנית התחתונה של.bigPic למשל עבור bigpicהמכיל את התמונה הבאה: 5 שורות # # # # # $ $ # # $ $ # $ $ $ $ $ $ 8 עמודות ועבור smallpic הבאה: 3 שורות # # # # # # # 3 עמודות הפונקציה תעדכן את bigpic להכיל את התמונה הבאה: 5 שורות # # # # # $ $ # # # # # # # $ # # # 8 עמודות הערות: בסוף כל שורה בתמונה מופיע התו 'n\'

25 typedef struct student{ char* name; int average; }STUDENT; שאלה 4 נתונה ההגדרה הבאה של רשומה שמירת נתונים על תלמיד: מאגר של תלמידים נשמר בקובץ בינארי לפי הפורמט הבא: המציין את מספר רשומות התלמידים הנמצאות בקובץ, נסמנו ב- n. מספר מטיפוס short int רצף של n רשומות, כאשר כל רשומה בנויה באופן הבא: המייצג את מספר התווים בשמו של התלמיד הנוכחי, נסמנו מספר מטיפוס short int ב-.len רצף של lenתווים, המייצגים את שמו של התלמיד הנוכחי (אין ' 0 \'בסוף רצף התווים הנ"ל). מספר מטיפוס int המייצג את ממוצע ציוניו של התלמיד הנוכחי. א. כתבו תוכנית המקבלת כפרמטר שם של קובץ המכיל נתוני תלמידים עפ"י הפורמט לעיל. התוכנית תיצור עבור קובץ התלמידים קובץ אינדקסים (קובץ המכיל נתונים של היסט יחסית לתחילת קובץ התלמידים), כך שאם נעבור על ההיסטים ברצף נקבל את התלמידים בסדר עולה של ציונים (הסטודנט המצטיין בסוף). על שמו של קובץ האינדקסים להיות השם של הקובץ המקורי בתוספת הסיומת.".ind" הערה: את המיון יש לבצע ע"י אלגוריתם יעיל ככל האפשר. ב. כתבו את הפונקציה הבאה: char ** findaveragegrade(char* database, int avggrade, int * ressize); הפונקציה מקבלת כקלט מחרוזת,database המייצגת שם של קובץ המכיל נתוני תלמידים (לפי הפורמט שהוצג בתחילת השאלה), ומספר,avgGrade המייצג ממוצע ציונים. על הפונקציה לייצר ולהחזיר מערך של מחרוזות המכיל את שמם של כל התלמידים שממוצע ציוניהם הוא avggradeאו NULL אם אין אף תלמיד כזה ב-.database במשתנה ressize יוחזר מספר התלמידים הנ"ל. הערות: 1. הניחו שהפונקציה הנ"ל נקראת רק אחרי שכבר נוצר קובץ אינדקסים, כפי שהוגדר בסעיף א', עבור הקובץ.database 2. שימו לב ליעילות זמן הריצה של הפונקציה אותה אתם כותבים

26 ביטים שאלה 1 חיפוש בספר טלפונים. נניח כי לכל לקוח בספר טלפונים יש 2 מחרוזות: typedef struct _client { char id[9]; // char phone[12]; // } Client; בשדה ת.ז. ישנן 8 ספרות (ללא ספרת ביקורת) ובסוף 0\. בשדה טלפון יש שלוש ספרות קידומת, סימן הפרדה - (מקף) ואח"כ 7 ספרות המספר עצמו בסוף. בסה"כ נשמרים 21 בתים ללקוח. ו \0 נרצה להקטין את כמות הבתים הנשמרת ללקוח, מבלי לאבד אינפורמציה. נשתמש במבנה הבא: typedef struct _short_client { unsigned char short_id[4]; unsigned char short_phone[5]; } Short_client; שימו לב כי כל התווים המשתתפים במידע שנשמר על לקוח הינם עוקבים בטבלת.ascii 0, 1, 2, 9, כאשר אין צורך לייצג את המקף כי הוא קבוע ומיקומו ידוע. מדובר בתווים: ישנם בסה"כ 10 תווים. ניתן לקודד מחדש כל תו ב 4 סיביות באופן הבא: קידוד זה מאפשר לשמור את המידע הרצוי במבנה החדש.Short_client א. כתוב פונקציה המקבלת מספר nומבצעת את הפעולות הבאות: 1. הקצאת מערך דינאמי של nרשומות מסוג Client 2. קליטת נתונים לתוך אברי המערך. 3. דחיסת הנתונים במערך למערך דינאמי של רשומות מסוג Short_clientתוך שחרור המערך הישן. 4. החזרת המערך הדחוס. ב. כתוב פונקציה המאפשרת חיפוש בספר טלפונים 1. הפונקציה מקבלת מספר ת.ז. כמחרוזת של 9 תווים. 2. העבר אותו לצורה הדחוסה 3. חפש אותו בלולאה במערך הדחוס. כאשר החיפוש מצליח, על הפונקציה להחזיר את המחרוזת המציינת מהו מספר הטלפון של הלקוח. (המחרוזת הינה בצורה המקורית ולא הדחוסה.) NULL אחרת. כתוב תוכנית המאפשרת ביצוע הפעולות הנ"ל

27 שאלה 2 כתבו תכנית שמקבלת 4 ארגומנטים: הארגומנט הראשון הינו מחרוזת המהווה שם של קובץ בינארי המורכב מבתים. הארגומנטים השני השלישי והרביעי (להלן (x,y,z הינם מספרים שסכומם חייב להיות. 8 נתון כי הקובץ מכיל מידע המקודד בביטים באופן הבא: בכל בית ישנו מספר המקודד ב x -ביטים השמאליים, מספר המקודד ב y -ביטים שאחריהם,ומספר המקודד ב z -ביטים האחרונים. לדוגמא :נניח כי x=4,y=3,z=1 ובקובץ ישנם 3 בתים אשר הייצוג הבינארי שלהם הוא כדלהלן ) משמאל לימין) הרווחים הם רק להמחשת החלוקה לבתים. המספרים המקודדים בבית הראשון הינם: המספרים המקודדים בבית הראשון הינם: המספרים המקודדים בבית הראשון הינם: כעת, נתונה הגדרה עבור מספר number ושכיחותו :frequency typedef struct { int number; int frequency; } Num_and_Freq; כמו-כן, נתונה ההגדרה הבאה לייצוג רשימה מקושרת של Num_and_Freq -ים: typedef struct listnode{ Num_and_Freq data; struct listnode* next; } ListNode; typedef struct list { ListNode* head; ListNode* tail; } List; על התכנית לייצר רשימה מקושרת המורכבת מהמספרים שהופיעו בקובץ הקלט. למשל, בדוגמא הקודמת סך הכל היו המספרים הבאים: 10 פעם אחת 0 פעמיים 1 פעמיים 5 פעם אחת 3 פעם אחת 2 פעמיים לכן ברשימה יהיו 6 תאים, התא הראשון יכיל את המספר הראשון שהופיע בקובץ (בדוגמא זהו המספר 10) וכן הלאה

28 שאלה 3 א. נתונה מחרוזת באורך n כך ש- n הינו כפולה של 8. נתון שבמחרוזת מספר התווים השונים הוא לכל היותר 8. כיוון שמספיקים 3 ביטים לייצג כל תו ניתן לצמצם את המקום הנדרש ביחס של 3/8. אופן הצמצום: לכל תו יותאם מספר בין 0 ל- (3 7 ביטים). באופן זה בכל שלושה בתים ייוצגו שמונה תווים במקום שלושה בלבד. על-מנת להתאים את המספרים, נעיין בסדרת התווים השונים מהמחרוזת המקורית, מסודרים לפי סדר הופעתם הראשונה, והערך שיוצמד לכל תו יהיה מיקומו בסדרה זו (החל מ- 0). לדוגמא: אם המחרוזת המקורית היא: :"aaaccbac" ל- a, יוצמד הערך 0. ל- c, יוצמד הערך 1. ל- b, יוצמד הערך והמחרוזת המצומצמת תהיה: הרווחים בין הספרות נועדו להמחשת הייצוג של כל תו. הקווים התחתונים מסמלים את הבתים השונים. ממשו ראשית את הפונקציה: char* getuniqueletters(char* text, int* size); המקבלת מחרוזת,text ומחזירה מערך המכיל את התווים השונים המופיעים ב-,text מסודרים במערך לפי סדר הופעתם במחרוזת.text הפונקציה גם מעדכנת במשתנה,size את גודלו של המערך המוחזר. למשל: אם תופעל הפונקציה עם,text="mullyllum" היא תחזיר את המערך: ['y','m'],,'u','l' ותעדכן בכתובת של sizeאת הערך 4. שימו לב: הערך המוחזר של הפונקציה הוא מערך של תווים, ולא מחרוזת (לא מסתיים ב- '0\'). כעת, כתבו תוכנית המקבלת כפרמטר שם של קובץ טקסט. ידוע שהקובץ הנ"ל מורכב משורות. אורכה של כל שורה מתחלק ב- 8 ובכל שורה יש לכל היותר 8 תווים שונים. על התוכנית להמיר קובץ זה לקובץ בינארי הבנוי לפי הפורמט הבא: עבור כל שורה בקובץ הטקסט, ישמרו בקובץ הבינארי הנתונים הבאים: 1. מספר מטיפוס unsigned char המייצג את מספר התווים השונים בשורה. 2. רצף (באורך זה) של char -ים המכיל את סדרת התווים השונים בשורה, מסודרים לפי סדר הופעתם הראשונה באותה שורה. 3. מספר מטיפוס unsigned int המייצג את מספר הבתים בהם נשמרים התווים המכווצים של השורה. 4. רצף (באורך זה) של בתים המכילים את הכווץ של השורה. שמו של הקובץ המיוצר הוא כשמו של קובץ הקלט, בתוספת ".rds" בסוף. לדוגמא:

29 נניח ש- "stam.txt" הוא קובץ טקסט, המכיל את שתי השורות: acbaccba mbbmbmmb אם תועבר לתוכנית, כפרמטר בשורת ההפעלה, המחרוזת,"stam.txt" התכנית תייצר את הקובץ."stam.txt.rds" קובץ זה יכיל: 3 'a' 'b' 'c' 'm' 'b' ב. כעת נרצה לשחזר מחרוזת מכווצת המכילה לכל היותר 8 תווים שונים, למחרוזת רגילה. כל 3 בתים במחרוזת המכווצת מייצגים שמונה תווים מהמחרוזת הרגילה. כל תו תופס 3 ביטים. את השחזור נבצע בעזרת מערך codeהמכיל את כל התווים השונים של המחרוזת, כאשר כל תו מופיע בדיוק פעם אחת. במחרוזת המכווצת במקום כל תו שומרים 3 ביטים המייצגים את המיקום של אותו תו במערך.code למשל אם המחרוזת המכווצת היא: והמערך ['x','o'] code = אזי המחרוזת המשוחזרת תהיה:."xooxoxxo" כתבו תוכנית המקבלת כפרמטר שם של קובץ בינארי עם סיומת.rds השומר מחרוזות בצורה מכווצת בהתאם לפורמט הנתון בסעיף א'. על התוכנית להמיר קובץ זה לקובץ טקסט. שמו של הקובץ המיוצר הוא כשמו של קובץ הקלט, ללא הסיומת.rds

30 שאלה 4 א. נתון תו מוצפן.ch על מנת לפענח אותו יש לשנות את מיקום הביטים בו. השינוי יעשה בעזרת תמורה ] 7 [a 0, a 1,, a של המספרים.0-7 תהליך הפענוח יעשה באופן הבא: את הביט האפס של התו ch נשים בביט שנמצא במקום ה- a 0 בתו המפוענח. את הביט האחד של התו ch נשים בביט שנמצא במקום ה- a 1 בתו המפוענח. וכך הלאה... הערה חשובה: הביט ה- 0 הוא הביט הימני ביותר כלומר ה- bit.(lsb) least significant למשל אם נרצה לפענח את התו שמיוצג בינארית: בעזרת התמורה: [3,2,1,0,7,6,5,4] נקבל את התו המפוענח שמיוצג בינארית: (למשל הביט האפס של התו המקורי (1) עבר לביט ה- 3 בתו המפוענח, וכו'). char decode(char ch, int* key); כתבו את הפונקציה: הפונקציה מקבלת תו מוצפן,ch ומערך keyבגודל 8 המכיל תמורה כלשהי של המספרים 0-7. הפונקציה תפענח את התו,ch עפ"י השיטה שתוארה לעיל, ותחזיר את התו המפוענח. ב. השתמשו בפונקציה מסעיף א' על מנת לכתוב את הפונקציה: char* decodestring(char* name, int* key); הפונקציה מקבלת מחרוזת name המכילה שם מקודד, ומערך key בגודל 8 המכיל תמורה כלשהי של המספרים 0-7. הפונקציה תיצור ותחזיר מחרוזת חדשה שתכיל את השם המפוענח. פענוח השם יתבצע ע"י פענוח כל אחד מתווי name עפ"י התמורה.key ג. שירות הביטחון הכללי שומר שני קבצים עבור כל פעולה שהוא מבצע. 1. קובץ בינארי (שאותו ניתן אפילו לשלוח ב- (mail המחזיק בצורה מוצפנת שמות של הסוכנים המשתתפים במבצע. 2. קובץ טקסט (שנשמר בכספת) המכיל את התמורות שבעזרתן ניתן לפענח את השמות המקודדים בקובץ הבינארי. פורמט קובץ השמות המקודדים (הקובץ הבינארי): שמות הסוכנים נשמרים ברצף. כל שם (מקודד) נשמר באופן הבא: מספר שלם int) (short המייצג את אורך שמו של הסוכן ואחריו רצף באורך זה של תווים מוצפנים המרכיבים יחד את שמו. פורמט קובץ המפתחות (קובץ הטקסט): הקובץ מורכב משורות. בכל שורה תופיע תמורה של המספרים 0-7 המופרדים ברווחים. סדר השורות בקובץ מתאים לסדר בו נשמרו השמות המקודדים בקובץ השמות. בפרט מספר השורות הוא כמספר הסוכנים בקובץ השמות. בהינתן ההגדרה הבאה למבנה עבור רשימה מקושרת: typedef struct l_node{ char* name; struct l_node * next; }L_NODE; typedef struct list{ L_NODE* head; L_NODE* tail; }LIST; כתבו את הפונקציה: LIST decodemission(file* agents, FILE* keys); הפונקציה מקבלת מצביעים לשני קבצים: -agents קובץ בינארי המכיל שמות מקודדים של סוכנים בפורמט שתואר לעיל. -keys קובץ טקסט המכיל מפתחות בפורמט שתואר לעיל

31 הפונקציה תחזיר רשימה, שתכיל את שמותיהם המפוענחים של הסוכנים המופיעים בקובץ.agents על הרשימה להכיל את הסוכנים לפי סדר הופעתם בקובץ. שאלה 5 א. כתבו את הפונקציה: int* filter(int* Numbers, int size, unsigned char* pred, int* new_size); הפונקציה מקבלת מערך Numbersשל מספרים שלמים שונים זה מזה, ואת גודלו.size כמו כן, היא size מקבלת מערך pred של ביטים, בגודל 8 בתים. כל ביט במערך,pred מייצג נתון אחד של המערך,Numbers באופן הבא: הביט ה- 0 בבית ה- 0 של המערך,pred מייצג את הנתון באינדקס 0 במערך.Numbers הביט ה- 1 בבית ה- 0 של המערך,pred מייצג את הנתון באינדקס 1 במערך.Numbers M הביט ה- 0 בבית ה- 1 של המערך,pred מייצג את הנתון באינדקס 8 במערך.Numbers וכך הלאה. הפונקציה תייצר ותחזיר את תת המערך המכיל אך ורק את הנתונים מהמערך,Numbers אשר הביט המתאים להם במערך,pred הוא 1. כמו כן, הפונקציה תעדכן במשתנה הפלט new_sizeאת גודלו של תת המערך שייצרה. Numbers למשל, אם המערכים Numbers ו-,pred מוגדרים באופן הבא: pred הקריאה size),filter(numbers, pred,,16 תייצר את המערך: וכן תעדכן במשתנה אליו מצביע new_size את הערך הערות: הניחו ש-,size מספר הנתונים במערך,Numbers מתחלק ב- 8. שימו לב כי בציור, האינדקסים במערך המספרים מתקדמים משמאל לימין, ואילו הביטים בכל בית נספרים מימין לשמאל (מה- LSB אל ה-.(MSB ב. השתמשו בפונקציה מסעיף א', על מנת לכתוב הפונקציה הבאה: int* xorfilter(int* Numbers, int size, unsigned char* pred1, unsigned char* pred2, int* new_size); הפונקציה מקבלת מערך Numbers של מספרים שלמים שונים זה מזה, ואת גודלו.size כמו כן היא size מקבלת שני מערכים pred1 ו- pred2 של ביטים, כל אחד מהם בגודל 8 בתים. כל אחד מהביטים, בכל אחד מהמערכים pred1 ו-,pred2 מייצג נתון מסוים של המערך,Numbers לפי ההתאמה שתוארה בסעיף א'

32 הפונקציה תייצר ותחזיר את תת המערך המכיל אך ורק את נתונים מהמערך Numbers כאשר נתון מסוים יופיע במערך התוצאה אם"ם בדיוק אחד מבין הביטים המתאימים לו במערך,pred1 ו-,pred2 הוא 1. כמו כן, הפונקציה תעדכן במשתנה הפלט new_sizeאת גודלו של תת המערך שייצרה. הערה: הניחו ש-,size מספר הנתונים במערך,Numbers מתחלק ב

33 פויינטרים לפונקציות שאלה 1 כתבו את הפונקציה: void* scramble(void* arr, int ElemSize, int n, int* indarr); הפונקציה מקבלת: -arr מערך של איברים מטיפוס כלשהו. arr גודל של כל אלמנט במערך -ElemSize.arr מספר האיברים במערך n-. 0,1, K,( n 1) מערך המכיל תמורה של המספרים: -indarr על הפונקציה ליצור מערך חדש שבו סדר האיברים נקבע על פי המערך indarrבאופן הבא: האיבר ה - iבמערך החדש יהיה האיבר שהאינדקס שלו במערך הישן הוא.indArr[i] למשל, אם = 3 n ו- [2,0,1] = indarr אז: במקום ה- 0 של המערך החדש ימצא האיבר מהמקום ה- 2 של.arr במקום ה- 1 של המערך החדש ימצא האיבר מהמקום ה- 0 של.arr במקום ה- 2 של המערך החדש ימצא האיבר מהמקום ה- 1 של.arr שאלה 2 נתון האלגוריתם הבא למימוש חיפוש בינארי של נתון במערך: קלט: פלט: מערך של נתונים.Arr גודל המערך - Size נתון לחיפוש.Item.(Arr מופיע במערך Item) אם"ם (true) found false.1 left 0.2 right (Size-1).3 (! found ( left right) 4. כל עוד ) place ( (left+right) div 2) אם (Arr[place]=Item) found true אחרת אם (Arr[place]<Item) left (place+1) אחרת right (place-1) החזר את found

34 א. כתבו את הפונקציה הבאה: int binsearch(void* Arr, int Size, int ElemSize, void* Item, int (*compare)(void*, void*)); על הפונקציה לממש אלגוריתם זה, למערכים מטיפוסים שונים (מערכים של מחרוזות, מערכים של int -ים וכו'). הפונקציה מקבלת: -Arr כתובת התחלה של מערך. -Size מספר הנתונים בו. -ElemSize מספר הבתים שתופס כל אחד מהנתונים. -Item כתובת של נתון שלגביו יש להכריע האם הוא נמצא במערך. טיפוס הנתון הוא כטיפוס נתוני המערך. -compare פויינטר לפונקציה המשווה בין שני נתונים (מהטיפוס של הנתונים מהמערך). על הפונקציה להחזיר את הערך 1 אם הנתון עליו מצביע Itemשווה לאחד מנתוני המערך, או 0 אחרת. הערה: הניחו שהפונקציה,compare מקבלת כתובות של שני נתונים אותם היא משווה. ומחזירה: אפס - אם שני הפרמטרים מצביעים על נתונים שווים. מספר שלילי - אם הפרמטר הראשון מצביע על נתון קטן יותר מהנתון שמוצבע ע"י הפרמטר השני. מספר חיובי - אם הפרמטר הראשון מצביע על נתון גדול יותר מהנתון שמוצבע ע"י הפרמטר השני. ב. השתמשו בפונקציה BinSearch,שכתבתם, על מנת לכתוב את הפונקציה: int stringbinsearch(char** strings, int size, char* str); המקבלת מערך stringsשל מחרוזות ממוינות בסדר לקסיקוגרפי, את גודלו,size ומחרוזת נוספת.str על הפונקציה להחזיר את הערך 1 אם המחרוזת str מופיעה במערך,strings או 0 אחרת. למשל אם stringsהוא המערך: abcdefg "good-luck" "mully" "stam" אז ההפעלה: (" stringbinsearch(strings,4,"good-luckתחזיר

35 שאלה 3 מאגר של נתונים על מוצרים נשמר בקובץ בינארי. הקובץ בנוי בפורמט הבא: מספר מטיפוס,int המייצג את מספר המוצרים בקובץ. נסמן את ערכו ב- N. 1. רצף באורךNשל נתונים של מוצרים. כל מוצר מופיע בקובץ בפורמט הבא: 2. מספר מטיפוס,int המייצג את מספר התווים בשמו של המוצר. נסמן את ערכו ב-.len רצף של lenתווים, המכיל את שמו של המוצר (ללא ' 0 \'בסופו). מספר מטיפוס,int המייצג את מחירו של המוצר. נרצה לייצר שני קבצי אינדקס לקובץ המאגר הנ"ל: מכיל את ההיסטים (offsets) למוצרים בקובץ המאגר, ממוינים לפי שם המוצר (מהקטן לגדול). מכיל את ההיסטים למוצרים בקובץ המאגר, ממוינים לפי המחירים שלהם (מהקטן לגדול). על מנת למנוע שכפול קוד ביצירת שני קבצי האינדקס, נגדיר פונקציה כללית ליצירת קובץ אינדקס ממוין, ונפעיל אותה פעמיים ליצירת כל אחד מקבצי האינדקס. בסעיף א' של השאלה נגדיר את הפונקציה הכללית ליצירת קובץ אינדקס ממוין, ובסעיף ב' נייצר את שני קבצי האינדקס הרצויים לנו. א. כתבו את הפונקציה: void createsortedindex(char* DB_Name, char* IndexFileName, int (*compare) (void*, void*)); הפונקציה מקבלת מחרוזת DB_Name המכילה את שמו של קובץ בינארי. הקובץ מכיל מאגר של נתוני מוצרים (לא ממוינים) בפורמט שהוגדר לעיל. הפונקציה מייצרת קובץ אינדקסים, בשם,IndexFileName המכיל רצף של נתונים מטיפוס,long int כל נתון בקובץ האינדקס, מייצג היסט מתחילת קובץ המאגר (DB_Name) לתחילת נתוניו של מוצר מסוים. אם נעבור על קובץ המאגר, לפי רצף ההיסטים בקובץ האינדקסים, המיוצר ע"י הפונקציה, נקבל את נתוני המאגר ממוינים מהקטן לגדול, עפ"י הסדר המושרה מפונקצית ההשוואה.compare הערה: הפונקציה compareהינה פונקצית השוואה כללית, המקבלת מצביעים לשני נתונים ומשווה ביניהם. הפונקציה משרה סדר באופן הבא: אם הנתון עליו מצביע הפרמטר הראשון קטן מזה שעליו מצביע הפרמטר השני, היא תחזיר מספר שלילי. אם הנתון עליו מצביע הפרמטר הראשון גדול מזה שעליו מצביע הפרמטר השני, היא תחזיר מספר חיובי. אם הנתון עליו מצביע הפרמטר הראשון שווה לזה שעליו מצביע הפרמטר השני, היא תחזיר את הערך 0. לצורך כתיבת הפונקציה,createSortedIndex ממשו (בין היתר) את הפונקציה: void sort(void* Arr, int elem_size, int num_elems, int (*compare) (void*, void*)); הפונקציה sort מקבלת מצביע Arr לתחילת מערך, מספר שלם elem_sizeהמייצג את גודלו של כל נתון במערך, ומספר שלם נוסף num_elemsהמייצג את מספר הנתונים במערך. הפונקציה ממיינת את הנתונים במערך,Arr עפ"י הסדר המושרה מפונקצית ההשוואה הכללית.compare

36 ב. השתמשו בפונקציה שכתבתם בסעיף א', על מנת לכתוב את שתי הפונקציות הבאות: void indexsortedbyname(char* DB_Name, char* IndexFileName); void indexsortedbyprice(char* DB_Name, char* IndexFileName); כל אחת מהפונקציות מקבלת שם של קובץ DB_Name המכיל מאגר של נתונים על מוצרים, בפורמט שפורט בתחילת השאלה. כל אחת מהפונקציות מייצרת קובץ אינדקסים בשם indexfilename (לפי הפורמט שהוגדר בסעיף א'). אם נעבור על קובץ המאגר, לפי רצף ההיסטים בקובץ אשר מייצרת הפונקציה הראשונה, נקבל את נתוני המאגר ממוינים לפי שם המוצרים, מהקטן לגדול. אם נעבור על קובץ המאגר, לפי רצף ההיסטים בקובץ אשר מייצרת הפונקציה השנייה, נקבל את נתוני המאגר ממוינים לפי מחיר המוצרים, מהקטן לגדול